spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

delete m_pGeschwindigkeit;

C-/C++-Quelltext

int a = 10;
const int& b = a; // b referenziert a
cout >> b; // 10
b = 20; // fehler, b ist const
int c = a; // copy
c = 20;
cout >> c >> a; // 20 10
int& d = a;
d = 20;
cout >> d >> a; // 20 20

//int* p = a; // meh
int* p = new int; // p --> [??]
*p = a; // a = 10, p --> [10]
a = 20; // p --> [10]
int& e = *p;
e = 25; // p --> [25]
delete p;

void main() {
    MyClass obj1; // calls ctor of obj1
    MyClass obj2(obj1); // calls copy-ctor of obj2 with obj1 as parameter
    obj1 = obj2; // calls assignment-copy-ctor of obj1 with obj2 as parameter
} // calls dtor of obj1 and obj2.

// assignment copy ctor:
class MyClass {
public:
    MyClass& operator = (const MyClass& rhs) { ... return *this; }
};

C-/C++-Quelltext

void Funktion(CRaumschiff schiff)
{
...
}

CRaumschiff jaeger;
Funktion(jaeger); // CRaumschiff schiff(jeager);

C-/C++-Quelltext

CRaumschiff jaeger;
CRaumschiff schiff(jaeger); // ruft den copy-ctor von der Klasse CRaumschiff für schiff auf, welcher eine Referenz auf jaeger bekommt.
...

C-/C++-Quelltext

struct MyStruct {
   int i;
   MyStruct() : i(10) {} // ctor von MyStruct mit initialisierer-liste, es wird der Copy-Ctor von int für i aufgerufen.
   //MyStruct() { i = 10; } // ctor ohne initialisierer-liste, es wird der copy-assignment-operator von int für i aufgerufen
   MyStruct(const MyStruct& rhs) : i(rhs.i) {} // copy-ctor von MyStruct, ruft den Copy-Ctor von int für i mit der referenz auf rhs.i als parameter auf
   //MyStruct(const MyStruct& rhs) { i = rhs.i; } // alternativer copy-ctor von MyStruct, hier wird statt des Copy-Ctors von i, der Assignment-Copy-Operator von i aufgerufen.
   MyStruct& operator = (const MyStruct& rhs) { // copy-assignment-operator für MyStruct - für aufruf siehe Copy-Ctor von MyClass
       i = rhs.i; // beachte: rhs ist referenz auf MyStruct.
       return *this;
   }
};

class MyClass {
private:
    MyStruct s;
public:
    MyClass() {} // Der ctor von s wird hier automatisch aufgerufen, entspricht also folgender Zeile:
    //MyClass() : s() {}
    MyClass(const MyClass& rhs) : s(rhs.s) {} // copy-ctor von MyClass. Für s wird der Copy-Ctor von MyStruct aufgerufen (Z. 5) mit einer Referenz zu rhs.s als parameter.
    //MyClass(const MyClass& rhs { s = rhs.s; } // alternativer copy-ctor von MyClass. Für s wird nun der Assignment-Copy-Operator aufgerufen. (Z. 7)
    MyClass& operator = (const MyClass& rhs) { // assignment-copy-operator für MyClass
        s = rhs.s; // ruft Assignment-Copy-Operator von MyStruct auf mit einer Referen zu rhs.s als Parameter auf.
        return *this;
    }
};

MyClass c1;
MyClass c2 = c1; // copy-assignment-operator von MyClass (Z. 20)
MyClass c3(c2); // Copy-Ctor von MyClass (Z. 18)