Using template types with arguments initialized

Question

How can I use a template class where I can call a constructor with some default arguments? Is this possible?

Ex:

#include <iostream>
#include <string>

using namespace std;

template <class T> class HoHoHo {
public:
    HoHoHo<T>(T yell);
    template <class TT> friend std::ostream& operator<<(std::ostream&, const HoHoHo<TT> &);
private:
    T yell;
};
template <class T> HoHoHo<T>::HoHoHo(T yell) {this->yell = yell;}
template <class T> std::ostream& operator<<(std::ostream &o, const HoHoHo<T> &val){ return o << "HoHoHo " << val.yell << "."; }

class Cls{
public:
    Cls(int a=0, int b=0);
    friend std::ostream& operator<<(std::ostream&, const Cls &);
private:
    int a;
    int b;
};
Cls::Cls(int a, int b){ this->a = a; this->b = b; }
std::ostream& operator<<(std::ostream &o,  const Cls &val) { return o << val.a << "," << val.b; }

int main()
{
  Cls cls(2,3);
  HoHoHo<Cls> hohoho(cls);
  cout << hohoho << endl; //This prints "HoHoHo 2,3"

  //DO NOT WORK
  HoHoHo<Cls(3,4)> hohoho_test(); // Want something like this?
  cout << hohoho_test << endl; // to print "HoHoHo 2,3"

  return 0;
}

Here I would like to be able to call the constructor of the template class with some default values. How do I achieve something like this?

I can write another class to encapsulate, but hoping there's a more clever solution.

I guess the way to do this IS encapsulation. thx @jive-dadson

template<int A, int B> class Cls_ext: public Cls {
public:
    Cls_ext<A,B>(){ this->a = A; this->b = B;}
};

and

  HoHoHo<Cls_ext<3,4> > hohoho_test; 
  cout << hohoho_test << endl; // prints "HoHoHo 3,4"

*"Looking for a general solution for a custom class that uses templates"* It is very unclear what you mean by that. — Baum mit Augen, May 02 '18 at 00:08
Read a [good c++ book](https://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list/388282#388282) — Passer By, May 02 '18 at 00:18
I can't tell if you're being sarcastic. Any good book will cover this content. — Passer By, May 02 '18 at 02:35
BTW, prefer initializers (`Cls::Cls(int a, int b) : a{a}, b{b} {}`) to writing assignments an the constructor. — Toby Speight, May 02 '18 at 11:15
@TobySpeight, yeah, just that it gave me an error with `Cls_ext(): a(A), b(B) {}`, so reverted back for both. Guess you can't do that with template params — xcorat, May 02 '18 at 18:17

score 3 · Accepted Answer · answered May 02 '18 at 00:29

I am not sure what you are asking, but maybe the template below is what you want. Notice that template parameters go in angled brackets <>, not parentheses.

#include <iostream>
#include <vector>

template<int A, int B>
class Cls{
public:
    Cls(): a(A), b(B) { }
    void Print(){ std::cout << a << "," << b << std::endl; }
private:
    int a;
    int b;
};

int main()
{
  std::vector<Cls<3,2>> vec(5); //Something like this?
  vec[0].Print(); // Should print "3,2"
}

score 2 · Answer 2 · answered May 02 '18 at 00:02

2

std::vector has a special constructor for repeating an element N times:

std::vector<Cls> vec(5, Cls(3,2));

answered May 02 '18 at 00:02

HolyBlackCat

78,603
9
131
207

That's good to know :) though I am actually looking for a general solution since I need it for a custom class that uses templates :/ – xcorat May 02 '18 at 00:03
1

@xcorat Then I think you need to restate your question. General how? – zdan May 02 '18 at 00:05
@xcorat It's not, at least to me. How using a template stops you from using this techinque? Something like `std::vector> vec(5, my_class(1,2));` works fine. – HolyBlackCat May 02 '18 at 00:15

score 0 · Answer 3 · answered May 02 '18 at 11:17

0

This line makes no sense, as HoHoHo requires a type template parameter:

  HoHoHo<Cls(3,4)> hohoho_test();

I think you meant:

  HoHoHo<Cls> hohoho_test(Cls(3,4));

answered May 02 '18 at 11:17

Toby Speight

27,591
48
66
103

Using template types with arguments initialized

3 Answers3