Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!
Werbeanzeige
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 |
#include <iostream> using namespace std; // Klassen // // Klasse für ein Raumschiff // class CRaumschiff { public: CRaumschiff (); ~CRaumschiff (); CRaumschiff (const CRaumschiff &rhs); void ZeigeWerte (); private: int *m_pGeschwindigkeit; }; // Konstruktor // CRaumschiff::CRaumschiff () { // Speicher reservieren // m_pGeschwindigkeit = new int; * m_pGeschwindigkeit = 1541; } // Konstruktor // Destruktor // CRaumschiff::~CRaumschiff () { // Wenn pGeschwindigkeit ein gültiger Zeiger ist, // Speicher wieder freigeben. // if (m_pGeschwindigkeit != NULL) { delete (m_pGeschwindigkeit); m_pGeschwindigkeit = NULL; } } // Destruktor // Kopierkonstruktor CRaumschiff::CRaumschiff (const CRaumschiff &rhs) { cout << "Kopierkonstruktor wurde aufgerufen."; cout << endl; // Tiefe Kopie m_pGeschwindigkeit = new int; *m_pGeschwindigkeit = *(rhs.m_pGeschwindigkeit); } // Kopierkonstruktor // ZeigeWerte // void CRaumschiff::ZeigeWerte () { // Wenn der Zeiger gültig ist, Geschwindigkeit anzeigen // if (m_pGeschwindigkeit != NULL) { cout << "Geschwindigkeit: " << * m_pGeschwindigkeit; cout << endl; } } // ZeigeWerte // Eine beliebige Funktion, die eine Instanz // der Klasse CRaumschiff übernimmt void Funktion (CRaumschiff Schiff) { Schiff.ZeigeWerte (); } // Funktion // Hauptprogramm // int main () { // Ein neues Raumschiff erzeugen CRaumschiff Jaeger; // Geschwindigkeit des Raumschiffs anzeigen lassen Jaeger.ZeigeWerte (); // Die Instanz an eine Funktion übergeben Funktion (Jaeger); return (0); } |
C-/C++-Quelltext |
|
1 |
delete m_pGeschwindigkeit;
|
Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »EizoTheAssAssin« (20.02.2015, 11:30)
Zitat
-Ich verstehe einfach nur nicht was genau wir neuen Speicher zuweisen (Z.57). Gehört der pointer auf m_pGeschwindigkeit (beim Programmdurchlauf) zu dem von uns erstellten Jaeger? Oder doch zu der Referenz? Oder einfach zu irgendeiner Kopie?
Zitat
-Desweiteren haben wir ja eine Referenz übergeben, also wenn wir diese ändern oder etwas neues zuweisen, dann ändert sich ja auch die Ausgangsvariable...In Z.58 haben wir jedoch nur einen Wert der Referenz genommen und ihn nicht verändert. Hab ich das so richtig verstanden?
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
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; } }; |
Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von »iSmokiieZz« (20.02.2015, 14:42)
Zitat
Auf Zeile 95 wird der Copykonstrutor mit Jeager als parameter aufgerufen.
Zitat
Beachte, dass man, wenn man den Copy-Constructor überlädt, man auch den Assignment-Copy-Constructor überladen sollte. Sonst werden die Daten bei der Zuweisung via = nicht kopiert (oder mithilfe des Standard-Assignment-Operators --> ungewünschtes Verhalten möglich). [1]
Zitat
Aber in der Zeile wird doch die Funktion "Funktion" aufgerufen.
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 |
void Funktion(CRaumschiff schiff) { ... } CRaumschiff jaeger; Funktion(jaeger); // CRaumschiff schiff(jeager); |
C-/C++-Quelltext |
|
1 2 3 |
CRaumschiff jaeger;
CRaumschiff schiff(jaeger); // ruft den copy-ctor von der Klasse CRaumschiff für schiff auf, welcher eine Referenz auf jaeger bekommt.
...
|
Zitat
m_pGeschwindigkeit (in Z.57) ist die Kopie des Zeigers des Jaegers und bekommt einen neuen Speicherbereich zugewiesen.
In der nächsten Zeile bekommt diese Kopie den Wert des Zeigers von der uns erstellten Referenz zugewiesen (Nicht die Adresse)
Zitat
Habe jetzt von dir, mir und nem anderen Forum was im Kopf , weiß grade garnicht welcher Schinken der richtige ist
Zitat
Habe den Copy Constructor garnicht überladen
Zitat
Wir haben hier den Normalen Konstruktor und den Kopierkonstruktor. Was ist denn der Assignment-Copy-Constructor?
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
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) |
Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von »iSmokiieZz« (21.02.2015, 10:37)
Ein neues Objekt wird erzeugt und der Kopierkonstruktor mit Jaeger als Parameter aufgerufen. Das passiert durch das Aufrufen automatisch. Wenn du das nicht willst musst du deinen Jaeger per Referenz oder Zeiger übergeben.
Werbeanzeige