C++: Pointer nicht auf Instanz, sondern auf Klasse selber um static aufrufen zu könne

[axeljaeger]

Hallo,
ich habe folgendes Problem: Ich habe einen Baukasten von Teilen auf dem Bildschirm. Man soll ein Bauteil markieren können und durch einen Mausklick auf eine Fläche soll ein entsprechendes Teil auf der Fläche erscheinen. Das soll man mehrmals machen können.

Jetzt habe ich mir überlegt, wie ich das geschickt lösen kann und da ist mir folgenden Idee gekommen: Ich repräsentiere die Bauteile als Subklassen der Klasse Tool, die in etwa so aussehen soll:

class Tool {
public:
virtual static Tool* create() {}
};

Jetzt soll durch Klick in den Kasten einfach ein Pointer auf das entsprechende Tool gelegt werden, so dass durch einen Klick in die Fläche die Methode create() des ausgewählten Bauteils aufgerufen wird. Und jetzt kommt der Kniff: Ich möchte nicht einen Pointer auf eine Instanz der Klasse anlegen, sondern auf die Klasse ansich. create() ist ja static.

Ich danke für kreative Lösungsvorschläge, ich denke nämlich, das ich es so nicht lösen kann.

[arthur]

wofür machst du eigentlich die create methode static ?
ohne sollte es wie gewünscht funktionieren
gruß
Arthur

[axeljaeger]

Weil ich ja, wenn die Methode nicht static ist, erst eine Instanz der Klasse erzeugen muss. Das soll aber erst passieren, wenn das Bauteil wirklich gebraucht wird, also bei einem Klick auf das Brett. Bei deinem Vorschlag müsste ich ja eine Instanz auf Vorrat halten oder eine spezielle Instanz haben, die nur dafür da ist, Instanzen von sich selbst zu erzeugen.

[wraith]

virtual und static geht nicht zusammen.
Was du vielleicht suchst, ist das Factory Pattern.

[axeljaeger]

Das mit der Factory ist mir auch schon durch den Kopf gegangen, aber da bräuchte ich ja pro Bauteil eine Factory.

[anda_skoa]

Nein, eine Factory kann auch mehrere Klassen erzeugen.

zb

class ToolFactory
{
public:
    Tool* createTool(Type t);
};

Oder einen String als Parameter, etc.

Bzw pro Tooltyp eine Factory Methode.

Ciao,
_

[axeljaeger]

@anda_skoa: An dieses ominöse Type t hatte ich auch schon gedacht, aber wie das verwendet wird, habe ich noch nirgends lesen können.

[anda_skoa]

Es geht nur um eine Möglichkeit, in der Methode zu entscheiden, was erzeugt werden soll.

Wenn die möglichen Typen bekannt sind, kann man einen enum definieren, der die einzelnen Tools beschreibt, also zb

enum ToolType {
    Line = 0,
    Resistor,
    Capacitor,
    Coil
};

Ciao,
_

[axeljaeger]

OK, also ein eigener Typ. Ich dachte, es gäbe einen Variable, die einen Datentyp speichern kann. Sowas ähnliches wie das Argument der sizeof-Funktion

[wraith]

Original geschrieben von axeljaeger
OK, also ein eigener Typ.

Besser, weil skalierbarer, ist du nimmst einen String (hat ja auch anda_skoa ein paar Posts vorher vorgeschlagen).

#include <string>
#include <map>
#include <algorithm>
#include <iostream>

class Base {
public:
   virtual ~Base() {}
   virtual void foo() { std::cout << "Base\n"; }
};

class Sub1 : public Base {
public:
   virtual void foo() { std::cout << "Sub1\n"; }
};

class Sub2 : public Base {
   const std::string name_;
public:
   Sub2(const std::string& name) : name_(name) {}
   virtual void foo() { std::cout << "Sub2 " << this->name_ << '\n'; }
};

Base* createBase() {
   return new Base();
}

Base* createSub1() {
   return new Sub1();
}

Base* createSub2() {
   return new Sub2("bar");
}

class Factory
{
   typedef Base* (*PFUN)();
   typedef std::map<std::string,PFUN> OBJLIST;
   typedef OBJLIST::iterator OITER;
   OBJLIST objList;
public:
   void registerObj(const std::string& name,PFUN pfun)
   {
      this->objList.insert(std::make_pair(name,pfun));
   }
   Base* create(const std::string& name)
   {
      OITER iter = this->objList.find(name);
      if(iter != this->objList.end())
      {
         return (iter->second)();
      }
      return 0;
   }
};

int main()
{
   Factory fac;
   fac.registerObj("Base",createBase);
   fac.registerObj("Sub1",createSub1);
   fac.registerObj("Sub2",createSub2);


   Base *pB = fac.create("Sub2");
   Base *pB1 = fac.create("Base");

   pB->foo();

   pB1->foo(); 
}

Sowas ähnliches wie das Argument der sizeof-Funktion

sizeof ist keine Funktion, es ist ein Operator.

[anda_skoa]

Mann bist du gut!

Ciao,
_