抽象的地图和stl中的向量

Question

If I have three types of maps and vectors:

map1<CString, int>
map2<CString, int, std::function1>
map3<some_wrapper_of_CString, int, std::function2>

In stl is there an abstract container or a way to write my own abstract container for the sole purpose of doing polymorphism:

abstract_map = map1 or map2 or map3

My class contains map1 which I cannot modify because it will crash other classes that my colleges at work use. I thought by creating an abstract map to wrap map1 I can pass map2 and 3 without other modifications...

I hope it makes sense.....

Answer 1

No, there isn't. What would be the purpose of it when the elements are not convertible to each other?

You can always do:

containera c;
containerb c2(c.begin(), c.end());

which will convert all elements from one to the other container.

If you actually have containers with the same underlying value_type the usual abstraction over the container type are iterators and not abstract containers.

After you have clarified that you only want type-erasure on the functor type:

class X {
  // constructor taking the full type
  X(const std::map<CString, int, std::function<bool(CString, int)>& x) : my_map(x) {}

  // constructor taking the default std::less
  X(const std::map<CString, int>& x) : my_map(x.begin(), x.end(), std::less<CString>()) {}

private:
  std::map<CString, int, std::function<bool(CString, int)> my_map;
};

Answer 2

In stl is there an abstract container or a way to write my own abstract container for the sole purpose of doing polymorphism

In the standard C++ library, there isn't.

Templates and dynamic polymorphism don't mix all that well.

Answer 3

Not only there are no abstract containers in the STL: you should never inherit from STL containers because they are not intended to behave polymorphically (no virtual destructor, for instance). So you have to look for a different solution.

In this case, you have to favour composition over inheritance. You may write your own abstract map class that contains an std::map , such as:

template<typename T>
class BaseMap
{
  // Whatever you need here

private:

  std::map<T> internalMap;
}

and then inherit from this class as needed:

template<typename T>
class Map1 : public BaseMap<T>
{
  // Specialise your class here
}

Of course, BaseMap should offer the interface you need for your maps, since it does not inherit std::map interface. You can write any virtual, pure virtual or non-virtual methods you need here.

Though maybe the first question you have to ask yourself is: do you really need different map classes? And, if so, do you really need them to be polymorphic?