Klassendesign frage

Katachi

Hallo,

Ich habe ein Nodesystem geschrieben. Dazu habe ich eine abstrakte BaseClass NodeCore, von dieser BaseClass leite ich dann die jeweiligen Nodetypen ab.

Jeder Node hat jedoch zusätzlich auch Eingänge und Ausgänge (Ports).
Die Ports sind eine eigene Klasse.

So schaut meine Klassenhierarchy ungefähr aus:

class NodeCore
{
   private:
      int type;

  public:
      virtual Ports* GetPorts() = 0;
      virtual void Run() = 0;
      //etc.
};

class GenNode : NodeCore
{
   private:
      GenNode(type) : NodeCore(type) {}
      Ports* ports;
   public:
      Ports* GetPorts();
      void Run();
      //etc.
};

Jetzt habe ich noch eine NodeGruppe Klasse die quasi die Nodes verwaltet.
Und hier mein Problem, bzw. meine Frage. Ich habe jetzt in der NodeGruppe Klasse einfach ein Array genommen und speichere die Nodes dann darin. Das erscheint mir jedoch unhandlich (da ich auch immer Speicher in der Grösse von NodeCore erzeuge und dann den Speicherblock eines neu erstellten nodes in das Array kopiere).

NodeGruppe
{
    private:
       NodeCore* nodes;

    public:
       NodeCore* GetNodes();
       bool InsertNode(NodeCore* n);
       //etc.
};

Wie würdert ihr die Nodes in der NodeGruppe verwalten? Ist ein Array ok oder was gibt es da noch für möglichkeiten?

Danke bereits für Meinungen
Sam

finix

Katachi schrieb:

Ist ein Array ok oder was gibt es da noch für möglichkeiten?

Statt Array würde ich eher zu std::deque tendieren. Obwohl, ohne genau zu wissen was diese NodeGruppe hauptsachlich anstellt wird's schwer dir nen konkreten Tipp zu geben.
Einfach mal einen Blick in die STL wagen, std::list, std::vector, std::set, käme uU alles in Frage...

p.s. NodeGroup wäre wesentlich konsistenter

Katachi

Danke erstmal. Ich habe jetzt std::vector genommen. Funzt wunderbar.

Jetzt habe ich aber noch eine Frage.

Ich habe jetzt die Funktionen nicht mehr rein virtuell mehr, sondern nur virtuell, da nicht alle abgeleiteten Klassen diese Implementieren müssen.

Wenn ich jetzt aber vom BasePointer eine virtuelle Funktion aufrufe, dann ruft er nicht die überladene Funktion der abgeleiteten Klasse auf, sondern immer die der Basisklasse (also NodeCore).

z.b. in der NodeCore klasse:

virtual int GetInportCount() 
{ 
     return 0;
};

und in der abgeleiteten Klasse:

int GetInportCount()
{
     return inport_cnt;
}

Aber es wird immer NodeCore::GetInportCount() aufgerufen, obwohl das Objekt eine Instanz der abgeleiteten Klasse ist:

NodeCore* n = new Operators(type);
ng->AddNode(n);

[...]
void NodeGroup::AddNode(NodeCore* node)
{
    nodes->push_back(*node);
    nodes->at(0).GetInportCount(); //liefert immer 0
}

Beim Debuggen sehe ich auch dass er immer die Funktion der Basisklasse aufruft. Was mach ich da falsch?

danke!

finix

Versuch's mit std::vector<NodeCore*> oder std::vector<boost::shared_ptr<NodeCore> > (oder sonst irgendein SmartPtr).

Und starte mal ne suche nach "Object-/Slicing". (Du kopierst quasi nur den NodeCoreteil deiner Objekte in den vector.)

Katachi

finix schrieb:

Versuch's mit std::vector<NodeCore*> oder std::vector<boost::shared_ptr<NodeCore> > (oder sonst irgendein SmartPtr).

Was mach ich mit denen genau. Sorry, bin noch Anfänger und da fällts mir schon schwer...

Und starte mal ne suche nach "Object-/Slicing". (Du kopierst quasi nur den NodeCoreteil deiner Objekte in den vector.)

Danke, jetzt versteh ich es ein bissl, aber die Suchfunktion hat mir nicht wirklich weitergeholfen (ich habe einige Threads gefunden, aber ich kapier das nocch nicht wirklich, auch google hilft nicht zu sehr weiter).

Katachi

finix schrieb:

Versuch's mit std::vector<NodeCore*> oder std::vector<boost::shared_ptr<NodeCore> > (oder sonst irgendein SmartPtr).

Ah ok, jetzt seh ich was du meinst. Scheint mit std::vector<NodeCore*> gut zu funktionieren.

Danke dir!