Ich habe 3 Klassen Group, Node und Shape
Node ist die Basisklasse von Group und Shape.

Group hat eine Liste in der Nodes gespeichert werden können.

Ich habe einen eigenen Kopier und Zuweisungsoperator für Node geschrieben.

Die Klasse Group soll Kinder hinzufügen können.

void sg::GroupNode::addChild(Node* child)
{
    Node* add_me = 0;
    if(GroupNode* gn = dynamic_cast<GroupNode*>(child))
    {
        add_me = new GroupNode(*gn);
    }
    this->children.push_back(add_me);
}

Aus Sicherheitsgründen wird von einem entsprechenden Knoten eine Kopie erstellt. <Achtung hier habe ich jetzt nur den Test auf Group und nicht alle Varianten.

Aber hierfür benötige ich auch den Kopierkonstruktor für GroupNodes (oder?)

die Klasse Group sieht im Grunde so aus:

class GroupNode : public Node
{
    list<Node*> children;
}

Wenn ich jetzt eine Kopie von einem solchen Knoten anfertigen will, müsste dieser wenn ich mich nicht irre auch sämtliche Kinder mitkopieren.

Nun sollte der Kopierkonstruktor von Group folgendes tun:
er soll den Kopierkonstruktor der Basisklasse aufrufen und dann alle Kinder kopieren.

Frage: geht das so:

(Antwort vorweg: nein, Compilermeldung:

/src/groupnode.cpp:14: error: no match for ‘operator=’ in ‘iter = other->sg::GroupNode::children.std::list<_Tp, _Alloc>::begin [with _Tp = sg::Node*, _Alloc = std::allocatorsg::Node*]()’

Die Meldung verstehe ich schon mal nicht ...

sg::GroupNode::GroupNode(const sg::GroupNode& other)  : Node(other)
{
    std::list<sg::Node*>::iterator iter;
    for(iter = other.children.begin(); iter != other.children.end(); iter++)
    {
        sg::Node* tmp = *iter;
        if( sg::GroupNode* copy_me = dynamic_cast<sg::GroupNode*>(tmp))
        {
            children.push_back(new sg::GroupNode(*copy_me));
        }
    }
}

In meiner Anwendung gibt es bisher nur Nodes und GroupNodes, der Rest kommt bald nach.

Ich poste gerne mehr Code con meiner kleinen Baustelle wenn notwendig...

class Node {
    virtual Node* clone() const {
        // ruft Kopierkonstruktor auf
        return new Node(*this);
    }
};

class Group : public Node {
    Group* clone() const {
        return new Group(*this);
    }
};
// usw

Wobei ich denke, entweder siehst du nur den Einsatz von Zeigern vor und verzichtest auf Kopiersemantik, oder du erlaubst Kopien und verwendest auch Values. Die Beispielimplementierung ist damit weniger ideal.

Ich kann mir diese Fehlermeldung nicht erklären.

class GroupNode : public Node
{
    list<Node*> children;
}

Dennoch habe ich noch das Problem mit dem Iterator...
was ist daran falsch?

Ich kann mir diese Fehlermeldung nicht erklären.

Du brauchst nen const_iterator.

ich befinde mich innerhalb der Klasse GroupNode, da habe ich Zugriff auf private Elemente

@ l'abra d'or

ohne dass ich es ausprobiert habe bisher:
ich glaube das ist die lösung ^^

@ zombie

das mit clone war ne gute idee spart mir ne menge aufwand

so bis zum nächsten problem

kleine zwischenfrage:

sg::GroupNode::GroupNode(const sg::GroupNode& other)  : Node(other)

das kann ich schon so machen oder kann das Probleme geben?

@ FreakY<3Cpp:
ich befinde mich innerhalb der Klasse GroupNode, da habe ich Zugriff auf private Elemente

Ah ich hab nicht darauf geachtet wo deine Methode ist, okay