带有基类指针的虚函数+ STL容器

Question

I have a base class called Base which defines a virtual function. The class Derived now inherits from it and implements/overwrites that virtual function. The following code works just fine:

Base* pB = new Derived();
pB->virtual_function(); // function of class Derived gets called -> good

My problem is, that I now store all my derived instances in a STL container std::map<ID, Base*> . This seems to cause problems, because when I later iterate over that container and try for each Base * to call my virtual function, the runtime only recognizes the pointers as type Base * and does not call the overridden implementation in the class Derived .

Is there a way to get that working as intended or am I missing a crucial point here?

EDIT 1: Some additional code was requested, so here we go:

std::map<ComponentType, Base*> m_Components;
// The factory instantiates a Derived* (via functors) and returns it as Base*
Base* pB = m_pComponentFactory->createComponent(this, type);
// Lazy insert (since there is no map entry with key 'type' at that stage) 
m_Components[type] = pB;

[...]

Base* pB;
for(ComponentMap::const_iterator it = m_Components.begin(); it != m_Components.end( ); ++it) 
{
    pB = it->second;
    pB->virtual_function(); // goes to Base instead of Derived
}

EDIT 2: One thing I just realized is that I do not call dynamic_cast (or something similar) after creating the Derived instance via the functor (but I wouldn't know what to cast it to anyway since it is all generic/dynamic). It is just a return creator() with creator being the functor. Is that the issue?

Definition of creator type (the functon type):

typedef Base*(*ComponentCreator)([some params]);

Edit 3: The actual functor is for example defined like this (Renderable and Location being derived classes from Base):

&Renderable::Create<Renderable> // or
&Location::Create<Location>

with the Create() method being a template function in the class Base.

template<typename T> 
static Component* Create([some params]) 
{ 
    return new T([some params]); 
}

EDIT 4: The problems seems to be my clone() + CopyConstructor handling. My clone currently looks like this:

Base* Base::clone() const
{
    return new Base(*this);
}

Since I only create a Base *, the virtual resolution later on cannot work. The problem I am now left with though, is that I a missing an idea how to change the cloning. As shown in EDIT 1 I have my m_Components map with Base* pointers. I now need to clone them but I only know that they are of Base * and not of which exact derivative. One idea that comes to mind, might be to store functor used to create the Derived instance in the first place in the class, to reuse it later. So my clone would look something like this:

Base* Component::clone() const
{
    return m_pCreationFunctor([some params]);
}

Anyone seeing a better approach?

Answer 1

You are a victim of slicing. When you copy construct a Base, you will lose the Derived parts of the object. See http://en.wikipedia.org/wiki/Object_slicing for a bit more detail. If the base class is not supposed to be instantiated, you might consider making it abstract to prevent making this mistake in future.

The fix in this case is probably to have a virtual Base * clone() method and override it in derived classes.

ie

class Base{
...
virtual Base * clone() const = 0;
...
};

class Derived : public Base {
...
Base * clone() const override { return new Derived(*this); }
...
};

If you really want to avoid rewriting the clone method, you could use an intermediate CRTP class ie

struct Base{
    virtual Base * clone() = 0;
};

template <typename D>
struct B : public Base {
    virtual Base * clone() { return new D(*static_cast<D*>(this)); }
};

struct D : public B<D>{};