Factory-Klassen

Hallo leute,

mein fragen:

Man kann von factoryklassen ja objekte von klassen erstellen, die von einer basisklasse abgeleitet werden oder?!

class base
{};
class member1:public base
{};

class member2:public base
{};

class factory
{
 base* MakeIt(const string& classname)
 {
 if(classname == "member1)
    return new member1();
 else
   return new member2();
};

kann man auch eine factory schreiben, die verschiedenene (nicht abgeleitete klassen) zurückgibt?

wenn ja wie?

HumeSikkins

kann man auch eine factory schreiben, die verschiedenene (nicht abgeleitete klassen) zurückgibt?

Kann man, aber natürlich nicht beliebig viele. Außerdem muss der Aufrufer in diesem Fall natürlich auch einen konkreteren Typ kennen.

und wie würde das aussehen?

da brauch ich ja für jeden typ eine eigene funktion oder?

ein beispiel wäre vielleicht super?!

KroqGar

kann ich hier auch Fragen zu anderen Klassen stellen ?
will mich net verposten

habs so versucht, geht aber nicht..

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

class Member1:public Base
{
  public:
  void WhoIAm(){cout<<"Member1"<<endl;}
};

class Member2:public Base
{
 public:
 void WhoIAm(){cout<<"Base2"<<endl;}
};

class Base2
{
public:
 void WhoIAm(){cout<<"Base2"<<endl;}
};

template<class T>
class Factory
{
 public:

 T* ReturnIt(const string& ClassName)
 {
  if(ClassName == "Base")
   return new Base;
  else if(ClassName == "Base2")
   return new Base2;
  else if(ClassName == "Member1")
   return new Member1;
  else
   return new Member2;
 }
};
int main(int argc, char* argv[])
{
  Base* p;
  Factory<Base> BaseFactory;
  Factory<Base2> Base_Factory;
  p = BaseFactory.ReturnIt("Member1");
  p->WhoIAm();
  getch();

        return 0;
}

wie kann ich das richtig machen?
und vorallem, wo lösch ich den zeiger? in der main mit delete p?;

Artchi

Kauf dir das Buch "Modernes C++ Design", da steht ne geniale Factory-Implementierung drin. Damit kannste sogar einen Plugin-Mechanismus bauen.

ja werd ich viell machen, brauch aber jetzt nur diese eine lösung...

Was soll der Sinn davon sein?

Wenn du nichts gegen void-Zeiger hast dann ist es möglich.

In etwa

struct BaseCreator
{
   virtual void* create() = 0;
};

class Factory
{
   /// int ist der ID-Typ
   typedef std::map<int, BaseCreator*> CreatorMap;
...
};

template <class T>
struct Creator : BaseCreator
{
   void* create()
   {
      return (void*)new T;
   }
};

template <class CreatorT, int ID>
struct Registrator 
{
    Registrator()
   {  Factory::register(ID, new CreatorT); }
};

// Das hier nicht vergessen.
Registrator<1, Creator<int> > regInt;
Registrator<2, Creator<float> > regFloat;

Eine Lösung ohne void* gibt es imho nicht.
Den Creator könnte man auch als lokale Klasse innerhalb Registrator() erstellen.

Das ganze ist übrigens ungetestet.