kann mir jemand mal ein kleines beispiel geben?

kann mir jemand mal ein kleines beispiel geben?

Es gibt unzählige Beispiele und unzählige verschiedene Variationen von Factory-Klassen. Ein typisches Beispiel wo einfache Factory-Klassen zum Einsatz kommen: Objekte sollen nur unter Angabe ihres Klassennames erzeugbar sein. Hier baut man dann eine Factory, die letztlich eine Abbildung zwischen Klassenname und Erzeugungsfunktion ist. Du gibst der Factory einen Klassenname, z.B. "Foo" und sie erzeugt dir eine Instanz der Klasse.

// Basisklasse aller Klassen, die durch die Factory erzeugt werden können.
class Base { 
    ...
};

class Foo : public Base {...};
class Bar : public Base {...};

class Factory {
public:
    Base* createObject(const char* className);
};

Base* Factory::createObject(const char* className) {
    if (strcmp(className, "Foo") == 0) {
        return new Foo();
    }
    else if (strcmp(className, "Bar") == 0) {
        return new Bar();
    }
    ...
    else {
        throw UnknownClassName(className);
    } 
}

Natürlich ist eine if-else-if-else-Kaskade nicht gerade die sinnvollste Art und Weise sowas zu implementieren, aber deshalb ist das ja auch nur ein Beispiel

probleme stehen im code

class Base
{
 public:
  Base(int i=0){x=i;}
  void ShowItX(){cout<<"Base x:"<<x<<endl;}
 private:
  int x;
};

class FirstMember:public Base
{
 public:
  FirstMember(int j=0,int i=1):Base(j){y=i;}
  void ShowItY(){cout<<"FirstMember y:"<<y<<endl;}

 private:
  int y;
};

class SecondMember:public Base
{
 public:
  SecondMember(int j=0,int i=1):Base(j){z=i;}
  void ShowItZ(){cout<<"SecondMember z:"<<z<<endl;}
 private:
  int z;
};

class Factory
{
 public:
  Base* createIt(const char* classname)
  {
   if(strcmp(classname,"First")==0)
    {
     b = new FirstMember();
     return b;                  //so in ordnung?
    }
   if(strcmp(classname,"Second")==0)
   {
    b = new SecondMember();
    return b;
   }
   else
    throw UnknownClassName(classname);  //wie kann ich das verarbeiten??
  }
 private:
  Base* b;    //das hier richtig? oder ist zeiger falsch?
};

int main(int argc, char* argv[])
{
 Factory F;
 Base* b;            //da ja zeiger zurückgegeben wird
 try
 {
 b=F.createIt("First");     //aufruf so richtig?
 b->ShowItX();              //kann trotzdem nicht auch Methoden von First zugreifen, will ich ja aber,wie mach ich das richtig?
 }
 catch(...)            //wie kann ich die exc hier abfangen?
 {

 }
 getch();       return 0;
}

try
{
  b=F.CreateIt("Third")
  ...
}
catch(UnknownClassName& ex)
{
  //hier kannst du die Elemente von ex auswerten
}

Methoden der spezifischen Klassen anwenden: Am besten wäre es, du nutzt die Möglichkeiten von virtuellen Methoden (und überschreibst ShowItX() in den abgeleiteten Klassen). Zur Not könntest du auch einen dynamic_cast verwenden (und dich darauf vorbereiten, eine bad_cast-Exception aufzufangen).

(PS: Das Factory-Objekt braucht das erzeugte Base*-Objekt übrigens nicht unbedingt zwischenzuspeichern)

du bist zum Moderator aufgestiegen?

Glückwunsch...

also einfachso die funktionen dann aufrufen geht nicht?!

wie meinst das hier mit den virtuellen funktionen?Kannst mir da kurz ein beispiel geben?

Wirfts du immer Referenzen und keine Zeiger, CStoll?
Hat das einen Vorteil?

wie heisst diese factory? objectfactory od. classfactory?

deine frage verwirrt mich etwas!
was ist der unterschied?
btw was is eine classfactory?

deine frage verwirrt mich etwas!
was ist der unterschied?
btw was is eine classfactory?

ich habe irgendwo gelesen, es gibt 2 factories

ist es nicht besser, dass man vor einer factoryClass noch ein Interface bauen?
also die beiden interface kommunizieren miteinander.

sorry, aber ich weis nicht was du mir grad damit sagen willst!
wäre um eine erklärung dankbar!

class Factory
{
public:
Base* createIt(const char* classname)
{
if(strcmp(classname,"First")==0)
{
b = new FirstMember();
return b; //so in ordnung?
}
if(strcmp(classname,"Second")==0)
{
b = new SecondMember();
return b;
}
else
throw UnknownClassName(classname); //wie kann ich das verarbeiten??
}
private:
Base* b; //das hier richtig? oder ist zeiger falsch?

wozu braucht man hier Base* b?, muss man dieses Object intern verwalten?(zwischenspeichern)

if(strcmp(classname,"Second")==0)
 {
    return new SecondMember();
 }

Compiler wird nacher dieses noname Variable automatisch löschen

deine frage verwirrt mich etwas!
was ist der unterschied?
btw was is eine classfactory?

ich habe irgendwo gelesen, es gibt 2 factories

Es gibt viel mehr als zwei Factory-Typen. Du meinst wahrscheinlich, neben der hier präsentierten Factory-Variante (die meistens als Object-Factory bezeichnet wird), eine Abstract Factory, so wie sie durch das GoF-Pattern Abstract Factory beschrieben wird. Abstract deshalb, weil du hier zwei Hierarchien hast: Eine Hierarchie von zu erzeugenden Objekten und eine Factory-Hierarchie. Die verschiedenen konkreten Factories erzeugen dann verschiedene Member der Objekt-Hierarchie.
Eine google-Suche nach Abstract Factory sollte dir viele nützliche Informationen liefern.

Wirfts du immer Referenzen und keine Zeiger, CStoll?
Hat das einen Vorteil?

Ich werfe - wenn überhaupt - Objekte, da brauche ich mich nicht um die Beseitigung kümmern. Und fange sie dann als Referenz, das spart erstens Konstruktor-Aufrufe und nutzt zweitens die Polymorphie der Exception-Klassen aus (Stichwort: virtuelle Funktionen).

@Assambler: Virtuelle Methoden werden von der Basisklasse definiert (evt. sogar nur die Schnittstelle - dann sind es pur virtuelle Methoden) und von abgeleiteten Klassen neu deklariert. Welche Methode letzlich aufgerufen wird, hängt dann vom (dynamischen) Typ des Objekts ab:

class Base
{
public:
  virtual void ShowIt() { cout<<"Base Object"<<endl; }
};

class Derived
{
public:
  void ShowIt() { cout<<"Derived Object"<<endl; }
};

int main()
{
  Base* b=new Derived();
  b->ShowIt();
  delete b;
  return 0;
}

spart Ctor weil es ist eine Referenz oder muss man erst const Referenz benutzen?

Weil es eine Referenz ist (throw legt ein Objekt an, catch() bekommt entweder eine Kopie (wenn du per Wert fängst) oder einen Verweis (wenn du per Referenz fängst) von diesem Objekt übergeben)