Dynamiczne tworzenie podklas

Nie jestem pewien czy nazwa wątku oddaje sedno sprawy; jeżeli nie to przepraszam. Mojej przygody z oop ciąg dalszy: zastanawiam się czy jest możliwość wywoływania odpowiedniego konstruktora w zależności od podanego parametru. Pokazuję i objaśniam o co mi chodzu:

class Employee;
class A: public Employee;
class B: public Employee;
class C: public Employee;

// *** kod ***
void employ(const std::string str)
{
	if (str == "A")
	{
		A some_new_employee;
	}
	else if (str == "B")
	{
		B some_new_employee;
	}
	else if (str == "C")
	{
		C some_new_employee;
	}

    some_new_employee = generate_random_employee(some_new_employee);
	// *** dalej kod ***
} 

Oczywiście rozumiem że ww. kod jest niepoprawny. Chciałem zobrazować moje pytanie. Z tego co czytałem rozwiązanie tego problemu nie jest łatwe. Proszę o potwierdzenie tego. Czy macie pomysł jak to ładnie zaimplementować?

Do lektury: wskaźniki, dziedziczenie, polimorfizm.

A tak z grubsza:

class A: public Employee;
class B: public Employee;
class C: public Employee;
 
// *** kod ***
Employee *employ(const std::string str)
{
    Employee *result = nullptr;
    if (str == "A")
    {
        result = new A();
    }
    else if (str == "B")
    {
        result = new B();
    }
    else if (str == "C")
    {
        result = new C();
    }
    return result;
} 

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

class Employee {};
class A: public Employee {};
class B: public Employee {};
class C: public Employee {};
typedef Employee *makeEmployee();

map<string,makeEmployee*> maker
 {
    {"A",[]()->Employee*{ return new A(); }},
    {"B",[]()->Employee*{ return new B(); }},
    {"C",[]()->Employee*{ return new C(); }},
 };

int main()
  {
   Employee *tmp=maker["A"]();
   return 0;
  }

http://ideone.com/H2Gur6

mathsicist napisał(a):

rozumiem, że nie należy się ograniczać się wyłącznie do tych narzędzi których się już poznało (w moim przypadku nie do końca) i należy uczyć się nowych rzeczy jednak chciałbym umieć rozwiązać powyższy problem bez korzystania z kolejnej biblioteki. Mimo to dzięki
A nie musisz, to tylko podejście - esencją tego jest tablica:

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

class Employee {};
class A: public Employee {};
class B: public Employee {};
class C: public Employee {};
typedef Employee *makeEmployee();

struct { string code; makeEmployee *maker; } Tb[]= 
 {
    {"A",[]()->Employee*{ return new A(); }},
    {"B",[]()->Employee*{ return new B(); }},
    {"C",[]()->Employee*{ return new C(); }},
 };

int main()
  {
   Employee *obj=nullptr;
   string code="A";
   for(auto p:Tb) if(p.code==code) obj=p.maker();
   return 0;
  }

http://ideone.com/4Xnsfp

Nie wspominając o tym że jak na razie wszystko to ta sama biblioteka standardowa.