ich habe eine Klasse Node, die, wie der Name schon sagt, einen Zweig eines Baumes darstellen soll.
Die Klasse hat einen ctor mit dem Paramter str. str wird entsprechend geparst, damit der Baum erstellt werden kann. Zum Parsen und Aufbauen des Baumes nutz ich natürlich Rekursion.
Jetzt gibt es aber ein paar Stringoperationen, die nicht für jeden Teilzweig, der ja auch den ctor nutzt, ausgeführt werden sollen, sondern wirklich nur ein Mal am Anfang...

Der Benutzer soll also folgendes schreiben können:
Node node("1+2*3");
jetzt wird ein bestimmter ctor aufgerufen, der parst den String und dann gibt er den bearbeiteten String an den anderen ctor weiter...
Der andere ctor muss ja irgendwie gekennzeichnet werden, ich hab das jetzt gemacht, indem ich einen 2., einen Dummyparameter gesetzt hab...

Das ist aber nicht so ne wirklich schöne Lösung, finde ich, hat jemand eine bessere Idee?

MfG Eisflamme

also in etwa folgendermassen:

class Operator
{
protected:
    Operator* child;
public:
    Operator();
    virtual ~Operator();
};

class Klammer : Operator
{
public:
    Klammer(string code)
    {
        //parsen, 
        child = new Mal(codeInKlammer);
    }

};
class Mal : Operator
{
private:
    float num1;
    float num2;
public:
    Mal(string code)
    {
        //parsen, dann
        num1 = 4;
        num2 = 3;
    }

};
[cpp]

[cpp]
int main()
{
    Operator* root = new Root("(2+2)*3")

}

Ich hoffe, ich hab dich richtig verstanden und ich hab jetzt keinen Denkfehler gemacht.

noch nen kleiner link: http://en.wikipedia.org/wiki/Interpreter_pattern

daher rührt auch dein problem. wenn der Baum sich nicht selbst aufbaut, sondern von jemand anders aufgebaut wird, brauchst du nur einen ctor.

hat den vorteil, dass du den Code deines Baumes entlasten kannst, und dass der Baum vielleicht später in einem anderen kontext wieder benutzt werden kann.

okay, stimmt, das erscheint logisch.
Werde es dementsprechend umbauen, danke!

MfG Eisflamme