Can we "wrap" templated classes with non-templated classes in C++? - c++

Question

Disclaimer: I am afraid the short answer to my question is "not possible". But since I am not a C++ expert, I thought I still give it a try and ask here, maybe there is some kind of solution which I am just not aware of.
So I have templated container-like class MyContainer that internally stores data in a std::list<T>, where T is the class template type. This works fine.
Now I want to add another class, which has to map instances of that templated container class in a std::map<std::string, MyContainer>. However, the compiler asks me to provide the template class type for the value-part of the map, as in std::map<std::string, MyContainer<T>>. But I would rather omit this template here, since that would in turn require me to use templates for the wrapper class as well.
Thus my question: Is there a way to achieve what I am trying to do, omitting the template type for the wrapper class, at least to some extend? Or is this just not possible in C++, because the compiler needs that information in any case?

Answer 1

One common technique for doing this is inheritance.
You make MyContainer<T> inherit from some base class, such as MyBaseContainer. MyBaseContainer is not a template class, but MyContainer is. The MyBaseContainer class has virtual functions that the templated class overrides.
Then, you make your map of type std::map<std::string, MyBaseContainer*>. It will be able to call the virtual functions on the containers it stores, without having to know the template type of each one.
This is how std::function works.

Answer 2

This is possible but a bit tricky. If i understand you correctly you want each MyContainer class stored inside map to possibly have different template specialization (say some will hold std::list<int> while other will hold std::list<string>) then you value type for map can no longer be just MyContainer but rather class that could hold both list<int> and list<string>.
One way to do it to use inheritance as #IanPudney already pointed out.
However you can do this even without creating inheritance hierarchy for MyContainer classes if you instead declare map as map<string, boost::any> (see http://www.boost.org/doc/libs/1_61_0/doc/html/boost/any.html) that way you will be able to store any kind of MyContainer inside this map without the need to create inheritance hierarchy in advance.

Answer 3

There are two possible ways to do this without using inheritance but this may also depend on a few deciding factors. The first question is: Upon creating an instance of the outside class is the type of the template container known. If it is then this is an easy class to write. If it is not then it can still be done but there would be more work involved. If case is not known there are 2 ways to do this and the first is the one you are trying to avoid by not making this a class template. The second involves more work which some of the logic on how to define this class will be shown.
Pseudo Code: -- 1st Case Where Type Is Known Upon Creation
#include <map>
template<class T>
class MyContainer {
// ... Class Variables, Constructors & Methods
}
// For Demonstration We will say that `T` is known to be an int upon instantiation
class MyClass {
private:
std::map< std::string, MyContainer<int> > maps_;
public:
MyClass() {}
~MyClass() {
// Clear Out Map
}
void addItem( std::string& str, int value ) {
maps_.insert( std::make_pair( str, MyContainer<int>( value ) );
}
};
Now for the 2nd case where the type is not known using the method without templating the wrapper you will need to know of all of the types that this class can support and you will need to create typedef of each of these.
Pseudo Code -- 2nd Case Where Type Is Not Known:
#include <map>
template<class T>
class MyContainer {
// ... Class Variables, Constructors & Methods
}
// For Demonstration We will say that `T` is unknown before instantiation
class MyClass {
public:
typedef MyContainer<int> INTS;
typedef MyContainer<float> FLOATS;
typedef MyContainer<double> DOUBLES;
// And Do This For Every Type This Class Will Support.
private:
std::map< std::string, INTS > mapInts_;
std::map< std::string, FLOATS > mapFloats_;
std::map< std::string, DOUBLES > mapDoubles_;
// And You Will Need A Container For Each Supporting Type
public:
MyClass() {}
// If You Have Constructors Other Than Default That Excepts Parameter Types
// You Will Need A Constructor For Each Supporting Type
~MyClass() {
// Clear Out All Maps
}
void addInts( std::string& str, MyClass::INTS );
void addFloats( std::string& str, MyClass::FLOATS );
void addDoubles( std::string& str, MyClass::DOUBLES );
// And You Will Need A Corresponding Function For Each Type This Class Supports.
};