ich habe eine ganze reihe Klassen, die jeweils voneinander erben ...

jede Klasse bringt weitere Variablen mit ...

jetzt zu meiner Frage:
Kann man in der geerbten Klasse alle Variablen der Basisklasse setzen?

... beim Konstruktor geht das ja mit einer Initialisierungsliste

aber z.B. beim operator= wie funktioniert das dort?
Es werden nämlich immer mehr Sachen die initialisiert werden müssen und dann muss ich in der geerbten Klasse immer mehr schreiben ...

... ein bisschen Code dazu:

class A {
    public:
        A();
        A(int x) : x(x){};
        virtual ~A();

    public:
        int x;

    public:
        A operator=(const A &a){
            this->x = a.x;
        }

        A operator=(int x){
            this->x = x;
            return *this;
        }
}

class B : public A {
    public:
        B();
        B(int x, int y) : A(x), y(y){};
        virtual ~B();

    public:
        int y;

    public:
        B operator=(const B &b){
            this->x = b.x; //einmal hier
            this->y = b.y;
            return *this;
        }
}

class C : public B {
    ....
    public:
        C operator=(const C &c){
            this->x = c.x; //hier
            this->y = c.y; //und hier
            this->z = z.z;
            return *this;
        }
}

Bei den Zeilen mit Kommentar liegt mein Problem.

Gibt es da irgendeine Möglichkeit das irgendwie zuzuweisen?

... Vorschlägen und Angregungen stehe ich offen gegenüber ...

Gruß Simon

und analog in B - so geht der compilergenerierte Zuweisungoperator vor. Wenn deiner also diese Form hat, kannst du genausogut darauf verzichten, ebenso wie beim Copyctor. Zu beachten ist zudem, dass diese Implementierung nicht exceptionsicher ist, wenn irgendeine außer der ersten Zuweisung fehlschlägt.

also werde ich in Zukunft den +-Operator wohl automatisch erstellen lassen, wenn ich nichts besonderes brauch ...

... wird der Operator immer generiert, wenn er nicht definiert ist, oder wird er nichtmehr generiert sobald ich z.B. nen anderen +-Operator (z.B. mit einem int) geschrieben hab?

Gruß Simon

also werde ich in Zukunft den +-Operator wohl automatisch erstellen lassen, wenn ich nichts besonderes brauch ...

Das wird nicht gehen. Die einzigen Funktionen die der Compiler automatisch generiert (wenn du sie nicht selber deklarierst) sind folgende:

- Copy-Ctor
- operator=
- Dtor
- Default-Ctor (wird nicht mehr generiert, wenn du irgendeinen anderen Ctor deklarierst)

Alle weiteren, also auch deinen operator+, wirst du selber schreiben müssen.
Zur Operatorüberladung siehe auch meinen allgemeinen Artikel sowie den Artikel über boost::operators (die Bibliothek kann dir ne Menge Arbeit abnehmen bei den Operatoren).

Vererbung wird von Neulingen oft missbraucht.

Gruß,
SP

@pumuckl: Oh, entschuldigung, ich meinte auch eigentlich den =-Operator, mir ist klar das ich den +-Operator selbst schreiben muss, denn der Compiler weiß ja nicht, was ich genau vor habe ...

@Sebastian: Das ist mir klar, ich hab nur ein Minimalbeispiel gebracht, das mein Problem in etwa beschreibt ...

Trotzdem bedanke ich mich für die Antworten und entschuldige mich für die Unannehmlichkeiten die ich verursacht habe.

Gruß Simon

Die einzigen Funktionen die der Compiler automatisch generiert (wenn du sie nicht selber deklarierst) sind folgende:

- Copy-Ctor
- operator=
- Dtor
- Default-Ctor (wird nicht mehr generiert, wenn du irgendeinen anderen Ctor deklarierst).

Zusätzlich noch der Adressoperator.

Der Kommaoperator ist auch ohne eigene Überladung anwendbar, aber den würde ich nicht dazu zählen, weil er ja nicht wirklich zur Klasse gehört.

pumuckl schrieb:

Die einzigen Funktionen die der Compiler automatisch generiert (wenn du sie nicht selber deklarierst) sind folgende:

- Copy-Ctor
- operator=
- Dtor
- Default-Ctor (wird nicht mehr generiert, wenn du irgendeinen anderen Ctor deklarierst).

Zusätzlich noch der Adressoperator.

Ein überladener Adressoperator wird vom Compiler nicht automatisch generiert. Zudem muss dieser ohnehin nicht als Memberfunktion überladen werden - somit stellte sich die Frage, wann der Compiler entscheiden müsste, ob er diesen Operator selbst generiert oder nicht.

Nexus schrieb:

Der Kommaoperator ist auch ohne eigene Überladung anwendbar, aber den würde ich nicht dazu zählen, weil er ja nicht wirklich zur Klasse gehört.

Das hängt davon ab, wie man "zur Klasse gehören" auffasst.