Dynamisches Erzeugen unterschiedlicher Klassen

class Kommunikator
{
   public:
   Kommunikator(int param1, int param2)
   {
      ... // Hier könnte man das tun, was beide Klassen
          // gemeinsam haben
   }

   virtual ~Kommunikator()
   {
      ...
   }

   virtual void tueDies(void)=0;
   virtual void tueDas(void)=0;
}

class Protokoll1Kommunikator : public Kommunikator
{
   public:
   Protokoll1Kommunikator(int param1, int param2, int param3)
                 :Kommunikator (param1, param2)
   {
      // Mit param1 und 2 wird der Konstruktor von
      // Kommunikator aufgerufen
      ... // Konstruktor von Protokoll 1
   }

   ~Protokoll1Kommunikator()
   {
      ...
   }

   void tueDies(void)
   {
      ... // Wie Protokoll 1 dies tut.
   }
   void tueDas(void)
   {
      ... // Wie Protokoll 1 das tut.
   }
   private:
   void ganzgeheim()
   {
      ... // Etwas ganz Geheimes das nur Protokoll 1 macht
   }
}

class Protokoll2Kommunikator : public Kommunikator
{
   public:
   // Konstruktor wie oben


   void tueDies(void)
   {
      ... // Wie Protokoll 2 dies tut.
   }
   void tueDas(void)
   {
      ... // Wie Protokoll 2 das tut.
   }

   ~Protokoll2Kommunikator()
   {
      ...
   }
}

void main()
{
   int protokoll;
   ...
   Kommunikator* k;
   if(protokol==1) k = new Protokoll1Kommunikator(a,b,c);
   else if(protokol==2) k = new Protokoll2Kommunikator(...);
   ...
   k->tueDies();
   k->tueDas();
   ...

}

...zu langsam...

Also da gibt es ganz kluge Leute, die haben vor nicht langer Zeit
Designpatterns aufgeschrieben, wenn sich bei mir jemand um eine Stelle
als Programmierer bewirbt kommt die Frage nach Kenntnis von
Designpatterns:

Ich empfehle:

"Entwurfsmuster" von Gamma/Helm/Johnson/Vlissides

Adison-Weseley ISBN 3-8273-1862-9

Orginal ist auf Englisch, ist auch besser.

Dort findet man Fabrik und abstrakte Fabrik

Warum das Rad neu erfinden...