kopierkonstruktor...

hi!
ich habe diesen zuweisungsoperator... wie schreibe ich denn jetzt einen kopier konstruktor?!

klassse& klassse::operator= (const klassse &neu) {
	if ( this != &neu ) {
		art  = neu.art;
		wert = neu.wert;
	}
	return *this;
}

rüdiger

öhm, bist du sicher, dass nicht einfach die implizit generierten copy operatoren reichen und du wirklich eigene Versionen schreiben musst?

ansonsten so:

class klasse {
  klasse::klasse(const klasse &obj) : art(obj.art),wert(obj.wert) { }
  //...
};

HumeSikkins

Und falls dir die Symmetrie der beiden negativ auffällt, bietet es sich an den einen über den anderen zu implementieren. Konkret den Zuweisungsoperator über den Kopierkonstruktor (andersherum ist keine gute Idee):

klassse& klassse::klasse(const klassse& neu) 
    : art(neu.art)
    , wert(neu.wert)
{ }

klassse& klassse::operator= (const klassse &neu) 
{ 
    klasse temp(neu);
    swap(temp);
    return *this;
}

void klassse::swap(klassse& other) 
{
// Implementation abhängig von den Typen von art und wert
// Z.B.
    std::swap(art, other.art);
    std::swap(wert, other.wert);
}

Nur aus neugierde: Was für Typen haben art und wert?

art ist string, und wert ist int...

wäre dies ein korrekter kopierkonstruktor?

klassse::klassse(const klassse &kopie) {
	*this = kopie;
}

Shade Of Mine

???? schrieb:

wäre dies ein korrekter kopierkonstruktor?
klassse::klassse(const klassse &kopie) {
	*this = kopie;
}

Korrekt? vielleicht
theoretisch muesste er funktionieren. aber er macht bloedsinn.

denn er ruft fuer alle member den standard ctor auf und dann weist er zu. das ist natuerlich sau lahm.

HumeSikkins

???? schrieb:

art ist string, und wert ist int...

Wozu dann ein expliziter Copy-Ctor bzw. Copy-Assignment-Operator? Die automatisch generierten reichen doch aus.

???? schrieb:

wäre dies ein korrekter kopierkonstruktor?
klassse::klassse(const klassse &kopie) {
	*this = kopie;
}

Und falls dir die Symmetrie der beiden negativ auffällt, bietet es sich an den einen über den anderen zu implementieren. Konkret den Zuweisungsoperator über den Kopierkonstruktor (andersherum ist keine gute Idee)

Ich bleibe dabei, das ist keine gute Idee. Dieser Ctor ist unnötig ineffizient (Erzeugung + Zuweisung statt einfacher Initialisierung). Außerdem kann das leicht zu Fehlern führen:

class BadBug
{
public:
	BadBug() : ptr_(new int(0)) {}
	BadBug(const BadBug& other)
	{
		*this = other;
	}
	BadBug& operator=(const BadBug& other)
	{
		if (this != &other)
		{
			int* temp = new int(*other.ptr_);
			delete ptr_;	
			ptr_ = temp;
		}
		return *this;
	}
private:
	int* ptr_;
};

int main()
{
	BadBug b1;

	// PENG!
	BadBug b2(b1);

}

Ups.