C++ das Ändern einer Klasse, die als Referenz übergeben wird, ändert das ursprüngliche Objekt nicht

Question

Ich habe eine Klasse A, die einige Instanzvariablen enthält, und eine Klasse B, die einen Verweis auf der Klasse nimmt und die Instanzvariablen ändert. Nachdem Klasse B diese Variablen geändert hat, würden Sie denken, dass diese in der ursprünglichen Instanz der Klasse geändert würden, in diesem Fall jedoch nicht. Warum passiert das und wie kann ich das beheben?

class Foo { 
public: 
    int x; 
    int y; 
    Foo() { 

    } 
    Foo(int x, int y) { 
     this->x = x; 
     this->y = y; 
    } 
}; 

class Bar { 
public: 
    Foo foo; 
    Bar() { 

    } 
    Bar(Foo& foo) { 
     this->foo = foo; 
    } 
    void Swap() { 
     int tmp = foo.x; 
     foo.x = foo.y; 
     foo.y = tmp; 
    } 
}; 
int main() 
{ 
    Foo foo(4, 8); 
    Bar bar(foo); 

    std::cout << "this is x: " << foo.x << std::endl; //prints 4 
    std::cout << "this is y: " << foo.y << std::endl; //prints 8 

    bar.Swap(); 
    std::cout << "this is x: " << foo.x << std::endl; //prints 4, but should print 8 
    std::cout << "this is y: " << foo.y << std::endl; //prints 8, but should print 4 
} 

Answer 1

Klasse B ‚s Konstruktor dauert foo (der Parameter) Bezug genommen wird, sondern sofort kopiert sie in eine separate Instanz A (insbesondere in das foo Element); Swap arbeitet dann auf dem foo Mitglied, das, wie oben gesagt, nur eine Kopie des ursprünglichen Objekts ist.

Um Ihren Code zu verhalten, wie Sie erwarten, dass Sie auch das Mitglied foo eine Referenz machen müssen (oder ein Zeiger):

class Bar { 
public: 
    Foo &foo; 
    Bar() { 

    } 
    Bar(Foo& foo) : foo(foo) { 
    } 

(Hinweis, dass ich musste the member initialization list syntax weil Referenzen cannot be default-initialized and then reseated)

Answer 2

Sie übergeben einen Verweis auf den Konstruktor bar foo, aber dann zuweisen (Kopie), um die foo, die Sie unter Bezugnahme auf bar.foo bestanden haben.

Sie möchten es als Referenz auf ein Foo-Objekt deklarieren (oder darauf verweisen), kein separates Foo-Objekt.

Answer 3

Das Problem ist hier.

Foo foo; 
    Bar(Foo& foo) { 
     this->foo = foo; 
    } 

Auch wenn Sie durch Verweis die foo Argument, können Sie es zu einem Nicht-Referenzwert zuweisen, die in einer Kopie führt und Konten für das Problem Sie gestellt. Der erste Schritt zur Lösung besteht darin, Ihr Instanzfeld durch Verweis zu deklarieren.

Foo& foo; 

Dies führt jedoch zu einem Fehler, wenn Sie versuchen, es zuzuweisen. Zu diesem Zweck möchten wir eine spezielle Konstruktorinitialisierungssyntax verwenden. Es funktioniert im Grunde genommen genauso wie eine Zuweisung, führt aber eher eine Konstruktion aus als eine normale Zuweisung. Schreiben Sie Ihren Konstruktor wie folgt.

Bar(Foo& foo) : foo(foo) {} 

Sie werden auch Bar() vollständig den Standardkonstruktor entfernen müssen, da die meisten C++ Compiler Code ablehnen wird, die in einem nicht initialisierten Referenz führen könnte.