CODEWITHSUNDEEP
c++templatesmetaprogramming
pepero
pepero

Reputation: 7513

container of template class in c++

I have a template, which may be used with different stl map (map<int, int>, map<int, char>, etc.), as follows.

template <typename Map> struct TriMaps
{
  Map& next;
  Map& prev;
  Map& curr;
};

so, TriMaps<init, int> intTriMaps; TriMaps<int, char> charTriMaps;

Then, is it possible to have a container of the above TriMaps, in different type? e.g.

vector <TriMaps> vecMaps;

which contain intTriMaps and charTriMaps? Usually container requires the same type. But I really need a container for my case. No boost or third library available.

Upvotes: 0

Views: 383

Answers (2)

Jarod42
Jarod42

Reputation: 217255

You can't have a std::vector of different type

but if you can have base class

struct TriMapBase { virtual ~TriMapBase() = default; };
template <typename Map> struct TriMaps : TriMapBase { /* Your implementation */ };

Then you may have:

TriMapBase<std::map<int, int>> mapint;
TriMapBase<std::map<int, char>> mapchar;
std::vector<TriMapBase*> v = {&mapint, &mapchar};

but you have to use virtual functions or dynamic_cast to retrieve the correct type afterward... or use

Upvotes: 0

Ajay
Ajay

Reputation: 18411

First determine and finalize what this class template TriMaps is expected to do. In C++, you must initialize a reference to something. You probably need a non-reference type (or a pointer type). Consider:

template <typename Map> 
struct TriMaps
{
  Map next;
  Map prev;
  Map curr;
};

Usage:

TriMaps<int> IntMaps;
vector<TriMaps<int>> iv;

If you need two template type argument, you can do this way:

template <typename MapType1, typename MapType2>
struct TriMaps
{
   MapType1 a;
   Maptype2 b;
};

Usage:

TriMaps<int, float> IntMaps;
vector<TriMaps<int, float>> iv;

EDIT:

Carefully understand that following simple class will not compile.

class TriMap
{
   int & ref_int;
};

One approach is to refer a global variable (just to make it compile), or take an int& via a constructor.

// Approach 1
int global;
class TriMap
{
  int & ref_int;
public:
   TriMap() : ref_int(global) {}
};

// Approach 2
class TriMap
{
   int & ref_int;
public:
   TriMap(int & outer) : ref_int(outer) {}
};

Upvotes: 1

Related Questions