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?

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.

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

ein beispiel wäre vielleicht super?!

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?;

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.