6

When using std::map in c++, is it possible to store inherited classes as their "base class" in the map and still being able to call their overloaded methods? See this example:

#include <iostream>
#include <map>
class Base
{
    public:
    virtual void Foo() { std::cout << "1"; }
};

class Child : public Base
{
    public:
    void Foo() { std::cout << "2"; }
};

int main (int argc, char * const argv[])
{
    std::map<std:string, Base> Storage;
    Storage["rawr"]=Child();
    Storage["rawr"].Foo();
    return 0;
}

This following code writes "1". Which somehow tells me that polymorphism doesn't work when you use std::map.

Filip Ekberg
  • 36,033
  • 20
  • 126
  • 183
  • Look closely at what this code does: `Storage["rawr"]=Child();` The left side, `Storage["rawr"]` creates a new object with the default constructor for the map's value class. Then the `=` calls `operator=` on that object. There's no way for `operator=` to change the instance of the base class you constructed with `operator[]` into an instance of a different class. – David Schwartz Mar 11 '12 at 16:38

5 Answers5

16

Polymorphism doesn't work in that case because the std::map stores the Base as a value type, so the objects get sliced.

If you want to have polymorphism on stored objects, you need to store pointers or use one of the boost ptr containers to effect the same. This means you need to remember to delete the memory afterwards (please don't put pointers to stack objects into the map)

workmad3
  • 25,101
  • 4
  • 35
  • 56
3

Its case of Object Slicing. Try to insert with pointers.

In the presence of inheritance copying leads to slicing. That is, if you create a map of base class objects and you try to insert derived class objects into it, the derivedness of the objects will be removed as the objects are copied (via the base class copy constructor) into the map.

Hence, it is recommended to use pointers rather than copies itself.

aJ.
  • 34,624
  • 22
  • 86
  • 128
1

First idea is that to get polymorphism you need to call member method on pointer or reference. I would store pointer to base class in the map (the element that you store gets copied) and then call via pointer like this:

#include <iostream>
#include <map>

class Base
{
    public:
    virtual void Foo() { std::cout << "1"; }
};

class Child : public Base
{
    public:
    void Foo() { std::cout << "2"; }
};

int main (int argc, char * const argv[])
{
    std::map<std::string, Base*> Storage;
    Storage["rawr"] = new Child();
    Storage["rawr"]->Foo();
    return 0;
}

You get result "2".

Note: You have to take care of the allocated memory now.

stefanB
  • 77,323
  • 27
  • 116
  • 141
1

Dynamic polymorphism works only with references and pointers. In case of using containers, which copy objects around inside them -- only with pointers.

If you would force a cast from super type to base type without using pointer or reference, the object memory would be sliced. Check this out: Object slicing wikipedia article

0

No, you must store a pointer to the base class to get the polymorphical behavior. The way you do now will lead to slicing.

Johann Gerell
  • 24,991
  • 10
  • 72
  • 122