Przesyłanie referencjie raz utworzonego obiektu

Witam,

Mam następującą strukturę klas:

• A
• • B
• • • C

B dziedziczy po A, a C po B.

Klasa A jest abstrakcyjna, praktycznie nic nie wnosi do programu poza zestawem zmiennych i funkcji, które są dziedziczone przez B i C.
Ilość klas takich jak B i C może ulec zmianie więc muszę to zaprojektować jak najoptymalniej pod kątem dalszego dorzucania nowych klas.

Użytkownik w konsoli ma do wyboru w tym momencie dwie opcje (po dołożeniu nowych klas będzie analogicznie, więcej podpunktów):
Gdy wybierze 1, rozpocznie procedurę tworzenia obiektu B.
Gdy wybierze 2, rozpocznie procedurę tworzenia obiektu C.

Tworzę np. obiekt B bo użytkownik wybrał 1.
W tym momencie proces konfiguracji obiektu (wywoływanie jego metod itp). wygląd tak samo dla obu klas (do pewnego miejsca), więc tutaj pytanie: Jak przekazać obiekt do metody bez tworzenia kilku wersji dla każdego przypadku, tj:

void stepFirst(B& object_b, .....)....
void stepFirst(C& object_c, .....)....

Jeżeli dobrze zrozumiałe, jest to typowy problem, który da się rozwiązać polimorfizmem.

Może coś takiego, ale na mój gust masz jakiś błąd projektowy.

#include <iostream>
using namespace std;
struct A{ 
	int x;
	virtual void print() = 0;
};
struct B:A{ void print(){cout << x << "B" << endl;}};
struct C:A{ void print(){cout << "C" << x << endl;}};

template<typename T>
T *fun(){
	auto result = new T();
	result->x = 61;
	return result;
}

int main(){
	fun<B>()->print();
	fun<C>()->print();
	
	return 0;
}

Bardzo duże prawdopodobieństwo że @spartanPAGE ma racje co do błędu w projekcie, ale czasami zdarzają się takie potrzeby, wtedy:

#include <map>
#include <iostream>
using namespace std;

class A
  {
   public:
   typedef A *creator();
   typedef map<int,creator*> creatormap;
   static creatormap &getmap()
     {
      static creatormap amap;	
      return amap;
     }
   template<class T> static void reg(int value)
     {
      getmap()[value]=[] () -> A* { return new T(); };
     }
   static A *make(int value)
     {
      creator *fun=getmap()[value];
      return (fun?fun():0);
     }
  };
  
class B:public A
  {
   public:
   B() { cout<<"B"<<endl; }
  };

class C:public A
  {
   public:
   C() { cout<<"C"<<endl; }
  };

class D:public C
  {
   public:
   D() { cout<<"D"<<endl; }
  };

void reg()
  {
   A::reg<B>(1);
   A::reg<C>(2);
   A::reg<D>(3);
  }

int main()
  {
   reg();
   A *b=A::make(1); 
   A *c=A::make(2);
   A *d=A::make(3);
   A *a=A::make(0);
   if(!a) cout<<"is NULL and it is OK"<<endl;
   delete b;
   delete c;
   delete d;
   return 0;
  }

http://ideone.com/F5aFOS

Da się uprościć do:

#include <iostream>
using namespace std;

class A
  {
  };
  
class B:public A
  {
   public:
   B() { cout<<"B"<<endl; }
  };

class C:public A
  {
   public:
   C() { cout<<"C"<<endl; }
  };

class D:public C
  {
   public:
   D() { cout<<"D"<<endl; }
  };

typedef A *creator();
creator *Tb[]=
  {
   [] () -> A* { return new B(); },
   [] () -> A* { return new C(); },
   [] () -> A* { return new D(); }
  };

int main()
  {
   A *b=Tb[0](); 
   A *c=Tb[1]();
   A *d=Tb[2]();
   delete b;
   delete c;
   delete d;
   return 0;
  }

http://ideone.com/hKlfF1