Stack Freigabe

Braunstein

Den Copy-Constructor finde ich nicht gut. Bei deiner Klasse C funktioniert der zwar, es geht aber sofort in die Hose wenn C weitere Member bekommt. Warum nicht den Copy-Konstruktor von C aufrufen.

A(const A& other) : c_(new C(*other.c_)) {}

DocShoe

Warum wird C überhaupt dynamisch erzeugt? Ist es zu groß für den Stack?

brotbernd

Ja das stimmt. Ich war einfach zu faul C noch einen Copy Ctor zu verpassen.

Braunstein

Deine C-Version hat ja schon einen funktionierenden CopyKonstruktor.

DocShoe schrieb:

Warum wird C überhaupt dynamisch erzeugt? Ist es zu groß für den Stack?

Nur als Beispiel für den OP.

brotbernd

ohje ja, häm.. da war ich wohl jetzt einfach leicht verwirrt

Belli

Braunstein schrieb:

Deine C-Version hat ja schon einen funktionierenden CopyKonstruktor.

Ja eben. Eine Klasse hat doch von Haus aus erst mal immer einen Copykonstruktor und einen Zuweisungsoperator.
Deswegen ist:

Skym0sh0 schrieb:

und an dem punkt musst du gucken ob es auch einen copy contruktor und einen zuweisungs operator gibt

etwas zu schnell geschossen. Es ist doch zuerst mal zu überprüfen, ob die betreffende Klasse Speicher auf dem Heap allokiert, denn anderenfalls reicht die standardmäßige Flatcopy aus.

Danke für die Antworten. Leider habe ich etwas Probleme mit der Schreibweise wie hier zum Beispiel:

brotbernd schrieb:

C(int i) : n(i) {}

Ich weiß leider nicht wie ich das "lesen" kann. Bei google weiß ich leider nicht, nach was ich suchen sollte...

Leider weiß ich auch noch nicht, was ein Zuweisungsoperator genau macht?

Eisflamme

n wird mit i initialisiert, mehr ist das nicht.

Vorteil an dieser Schreibweise ist, dass du z.B. auch Konstanten initialisieren kannst. Wenn du die Zuweisung im Rumpf des ctors machst, geht das nämlich nicht mehr.

pumuckl

RandomQuestion schrieb:

Bei google weiß ich leider nicht, nach was ich suchen sollte...

nach "Initialisierungsliste", so heißt der Teil nach dem Doppelpunkt und vor der geschweiften Klammer.

Leider weiß ich auch noch nicht, was ein Zuweisungsoperator genau macht?

er sorgt dafür, dass nach a=b a äquivalent ist zu b. (zumindest sollte er das) Bei eingebauten Datentypen gibts den schon frei Haus:

int i(5); //i wird mit 5 initialisiert
i = 12; //Zuweisung, i ist jetzt 12

Bei zusammengesetzten Datentypen kann der Compiler den operator= automatisch generieren, wenn alle Member einen operator= haben:

struct St 
{
  int i;
  double d;
};

St s;
s.i = 5;
s.d = 6;

St s2;
s2.i = 13;
s2.d = 14;

s = s2; //Zuweisung: s.i wird s2.i zugewiesen, s.d wird s2.d zugewiesen

Wenn die automatische Zuweisung aber nicht das richtige macht (z.B. wenn ein Member ein Pointer auf Speicher ist, der dem Objekt gehört und vonihm verwaltet wird), muss man den operator selber schreiben.

Würde dies als Copy Constructor funktionieren?

class A
{
    A::A(const A& other)
    :   var1(other.var1),
        var2(other.var2),
        var3(new C(*other.var3)),
        var4(other.var4),    // hier soll keine Kopie erzeugt werden, sondern auf die gleiche Instanz verwiesen werden. Passt das so?
        var5(other.var5)
    {
    }
    std::string var1;
    bool var2
    C* var3;
    D* var4;
    std::list<std::string> var5;
};

Ist ein Zuweisungsoperator damit eine weitere Funktion oder habe ich das mit dem Copy Konstruktor abgehackt?

Zuweisungsoperator ist ne weitere Funktion.

A operator=(const A& other) {}

Copy-Ctor ist dafür da wenn du sagst "Ich hab hier ein A-Objekt, mach mir bitte noch ein A-Objekt mit Hilfe des ersten". Zuweisungsoperator heißt "Ich habe zwei A-Objekte, mach bitte dass das erste genauso aussieht wie das zweite."

Von der funktionalität ist es sehr ähnlich, so ähnlich das der copy-ctor manchmal einfach mit

A(const A& other) 
{
*this = other;
}

implementiert wird. Gibt Gründe die dafür und dagegen sprechen das so zu machen.

Bei deinem copy-ctor sehe ich atm das Problem, das du wieder eine bloße Kopie von D* var4 machst, anders als bei var3. Nur vergessen, oder ist das Absicht?

Sollte natürlich

A& operator=(const A& other)

heißen

pumuckl

kleiner Troll schrieb:

Bei deinem copy-ctor sehe ich atm das Problem, das du wieder eine bloße Kopie von D* var4 machst, anders als bei var3. Nur vergessen, oder ist das Absicht?

Der Kommentar in Zeile 7 schreit doch ganz laut "Absicht"

ich = blind (Hausaufgabe: implementiere passenden Zuweisungsoperator für diese Zuweisung.)

314159265358979

Oft wird der op= auch als T& operator = (T); implementiert, siehe Copy & Swap Idiom.

Wäre das dann schon mein Zuweisungsoperator (wenn der Copy Konstruktor schon wie oben existiert)?

A& operator=(const A& other)
{
    return A(other);
}

Eisflamme

Der ist schlecht, du kannst doch nicht einfach ein lokal erstelltes Objekt als Referenz zurückgeben.

Der Zuweisungsoperator soll die Attribute des Objekts dem this-Objekt zuweisen und anschließend *this zurückgeben, so ist das gedacht.