Tengo una estructura de clase similar a la siguiente

class A
{
public:
    A(void);
    ~A(void);

    void DoSomething(int i)
    {
        std::cout << "Hello A" << i << std::endl;
    }
};

class B : public A
{
public:
    B(void);
    ~B(void);

    void DoSomething(int i)
    {
        std::cout << "Hello B" << i << std::endl;
    }
};

class Ad : public A
{
public:
    Ad(void);
    ~Ad(void);
};

class Bd : public B
{
public: 
    Bd(void);   
    ~Bd(void);
};

Quiero almacenar instancias de las clases derivadas en un contenedor (mapa estándar) como una colección deUNA*, luego itere a través del contenedor y llame a los métodos para cada instancia.

#include "A.h"
#include "B.h"
#include "Ad.h"
#include "Bd.h"
#include <map>
int main(int argc, char** argv)
{
    std::map<int,A*> objectmap;
    objectmap[1] = new Ad();
    objectmap[2] = new Bd();

    for (std::map<int,A*>::iterator itrobject = objectmap.begin();
         itrobject!=objectmap.end(); itrobject++)
    {
        itrobject->second->DoSomething(1);
    }
    return 0;
}

El código anterior produce la siguiente salida.

Hello A1
Hello A1

Donde estaba esperando

Hello A1
Hello B1

porque estaba esperandoHacer algo enB esconderHacer algo enA, y porque estoy almacenandoA punteros, esperaría que no se rebane el objeto (y si observa el puntero del objeto en el depurador se muestra que el objeto no se ha cortado)

He intentado el lanzamiento y el lanzamiento dinámico del puntero aB, pero corta los datos de los miembrosBd.

¿Hay alguna manera de llamarB :: DoSomething sin lanzar el puntero aBd? Y si no, si tengo muchas clases derivadas deB (p.ej.Bda, Bdb, Bdc etc), ¿hay alguna forma de usar RTTI para saber a qué clase derivada se puede convertir?