kann folgendes (sinnvoll) funktionieren?:

class B
{
public:
    A meth()
    {
        A a = A();
        a.do();

        return a; //wird a hier schon aus dem Stack entfernt?! bzw. Wann wird es entfernt
    }
};

int main()
{
    B b;
    A a = B.meth();
    // ...can I use a here?!
}

weil eine kopie zurückgegeben wird
und an dem punkt musst du gucken ob es auch einen copy contruktor und einen zuweisungs operator gibt

class C;
class A
{
public:
    C* c;
    A ()
    {
        name = "test";
        c = new C();
    }
private:
    string name;
};

Was ist ein Zuweisungs Operator?

aber jetzt hast du das prblem verschoben und du brauchst einen sinnvollen copy CTor in C...

das sit ein schlechtes beispiel was du jetzt wolltest

Ah ok, da liegt also der Hase begraben... Ich brauche wahrscheinlich einen Copy Konstruktor?! wie würde der von folgender Klasse aussehen?

Das kommt darauf an, ob eine Kopie einer A Instanz eine neue C Kopie erhalten soll, oder auf die selbe Instanz verwiesen soll. Im zweiten Fall stellt sich die Frage wer die Instanz dann löscht. Um sich die Arbeit zu erleichern, sollte man in so einem Fall dann einen std::shared_ptr<C> verwenden. Der compilergenerietre Kopierkonstrujktor und Zuweisungsopertor, wäre dann für A ausreichend.
Im ersten Fall sieht A z.B. so aus

class C
{ 
public:
    C(int i) : n(i) {}
    int n; 
};

class A
{
public:
    A(int i) : c_(new C(i)) {}

    A(const A& other) : c_(new C(other.c_->n)) {}

    // zuweisungs operator
    A& operator=(A other)
    {
        // copy swap
        other.Swap(*this);
        return *this;
    }

    void Swap(A& other)
    {
        std::swap(c_, other.c_);
    }

    C* c_;
};

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

DocShoe schrieb:

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

Nur als Beispiel für den OP.

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.

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?

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.

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.

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?

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?

A& operator=(const A& other)

heißen

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"

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

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