assignment operator überladen gibt keine referenz zurück sondern kopiert

fairy2211

Hallo,

Ich lerne gerade C++ und hier sollte beim 2. Ändern von b.set_member(3) auch a.get_member() 3 ausgeben, denn der operator wurde so überschrieben, dass er eine referenz zurückgibt.


#ifndef GUARD_namespacetest_h
#define GUARD_namespacetest_h

#include <iostream>

class NamespaceTest {
		public:
		NamespaceTest(int, double);
        NamespaceTest(const NamespaceTest& ref){
            member = ref.member;
            member2 = ref.member2;
            std::cout << "1 called." << std::endl;
        }
        NamespaceTest& operator=(NamespaceTest& ref){
            std::cout << "2 called." << std::endl;
            return ref;
        }

		//int* get_member() const;
        int get_member();
        void set_member(int x);

        double get_member2() const;



		private:
		int member;
		double member2;
	};

#endif


#include "NamespaceTest.h"
#include "CircularIncludeTest.h"

int NamespaceTest::get_member() {
    return member;
}

void NamespaceTest::set_member(int x){
    member = x;
}

double NamespaceTest::get_member2() const{
    return member2;
}

NamespaceTest::NamespaceTest(int a, double b): member(a), member2(b){};

#include <iostream>
#include <vector>
#include "NamespaceTest.h"
#include <iterator>
#include <string>
#include <algorithm>
#include <map>
#include <iterator>
#include <string>


int main(){
	
	// constructor called.
	NamespaceTest a = NamespaceTest(1,2.2);
	// copy constructor called: NamespaceTest(const NamespaceTest& ref)
	// prints 1 called.
	NamespaceTest b = a;
	b.set_member(2);
	std::cout << a.get_member() << std::endl;
	// assignment operator constructor called
	// prints 2 called.
	b = a;
	b.set_member(3);
        // should print 3 but prints 1
	std::cout << a.get_member() << std::endl;
	return 0;
}

wob

@fairy2211 sagte in assignment operator überladen gibt keine referenz zurück sondern kopiert:

NamespaceTest b = a;

Das erzeugt eine Kopie. Du müsstest schreiben

NamespaceTest &b = a;
// oder:
auto &b = a;

Und das hier ist Blödsinn:

        NamespaceTest& operator=(NamespaceTest& ref){
            std::cout << "2 called." << std::endl;
            return ref;
        }

Das solltest du so nicht machen. Du willst stattdessen eine const & als Parameter haben, damit du auch non-const Objekte zuweisen kannst.

Th69

Die Zuweisung b = a ist äquivalent zu b.operator =(a).
Durch die Zuweisung b = a gibst du zwar eine Referenz zurück, diese wirkt sich aber erst bei weiterer Zuweisung aus, z.B. c = b = a.

Und da du (bisher) keine Änderung in NamespaceTest& operator=(NamespaceTest& ref) durchführst, ändert sich auch nichts an b (und erst recht nicht an a).
Analog zu deinem letzten Beitrag, solltest du hier NamespaceTest& operator=(const NamespaceTest& ref) verwenden (damit man die Zuweisung auch für ein konstantes Objekt aufrufen kann und du dieses eben nicht ändern kannst).

Außerdem muß man stattdessen *this dann als Referenz zurückgeben, damit sich Änderungen dann auf b (und nicht a auswirken):

Namespace &c = b = a;
c.set_member(3);
std::cout << a.get_member() << std::endl; // gibt weiterhin 1 aus
std::cout << b.get_member() << std::endl; // gibt nun 3 aus
std::cout << c.get_member() << std::endl; // ebenfalls 3

Edit: @wob, es geht um die Zuweisung b = a (in Zeile 23).

wob

@Th69 sagte in assignment operator überladen gibt keine referenz zurück sondern kopiert:

Edit: @wob, es geht um die Zuweisung b = a (in Zeile 23).

Ah, hast recht - habe wegen so viel Noise im Code nicht richtig geguckt.

fairy2211

Dieser Beitrag wurde gelöscht!

fairy2211

cool danke euch beiden!