Applikation:

void main()
{
	int usize = 0;
	cout <<"enter size for u = "; cin>>usize;

	Vector u(usize),v(10),w(10); 

	v[1] = 0.2;
	w[1] = 3;

	double x = v*w;
	cout << x << endl;
         cout<<"what is the return: "<<endl;
         u = v+w; //u = ?????????????????????
	cout << u;
}

in der Methode operator + ein lokal erzeugtes Objekt wird zurückgegeben(als kopie),aber wenn man operator = aufruft (u = v+w),das parameter hat seinen Wert nicht mehr, wieso?

for(int i = 0 ; i < size; ++i)
{
    temp[i] = array[i] + a[i];
}

ergebnis ist das selbe, es geht nicht um den korrekten wert

bau noch nen copy-ctor

wie soll der aussehen?

Vector(const Vector& src) : array(new double[src.size]), size(src.size)
{
   std::copy(src.array, src.array+size, array);
}

void Swap(Vector& src)
{
   std::swap(array, src.array);
   std::swap(size, src.size);
}

Vector& operator =  (const Vector& a)
{
    Vector tmp(a);
    Swap(tmp);
    return *this;
}

//copy-ctor
Vector(const Vector &original)
{
    //Werte kopieren
    operator=(original);
}

Stimmt, für eine Kopie wird natürlich ein Kopier-Konstruktor benötigt, hatte ich auch übersehen
Man kann übrigens den operator auch im Konstruktor verwenden:

//copy-ctor
Vector(const Vector &original)
{
    //Werte kopieren
    operator=(original);
}

Wieder einer, der meinte, sehr schlau zu sein. Führt erstens in diesem Falle zu Endlosrekursion, zweitens ist das Objekt beim Aufruf noch nicht zerstörbar, drittens ist es sowieso unlogisch, das so zu machen. Wieso will eigentlich jeder das Einfache (Copy-Ctor) durch das Komplizierte (Copy-Zuweisung) implementieren?

welches problem könnte verursacht werden, wenn das objekt beim aufruf noch nicht zerstörbar ist? hat das etwas mit exceptions zu tun?

umgekehrt, wenn der operator= den kopierkonstruktor benutzt, wird es nämlich komplizierter, da man sowas wie swap benutzen muss.

Wenn man beide komplett ausprogrammiert, ist der op= immer der kompliziertere, weil er ein vorinitialisiertes Objekt erst "leeren" muss. Und wenn man auch noch auf die Idee kommt, so etwas wie du da zu fabrizieren, dann müsste der op= auch noch mit einem uninitialisierten *this zurechtkommen. Und auf Selbstzuweisung muss man auch noch prüfen.

Der Copy-Ctor ist da viel einfacher zu implementieren. Da ist immer klar, in welchem Zustand sich das Zielobjekt befindet.

Die "Copy&Swap"-Implementierung des op= ist eine schöne, einfache, immer funktionierende, exception-sichere. Man muss nur einen ordentlichen Copy-Ctor schreiben.

die lösung war auf die ursprüngliche, einfache implementierung des operator= bezogen. umgekehrt, wenn der operator= den kopierkonstruktor benutzt, wird es nämlich komplizierter, da man sowas wie swap benutzen muss.

welches problem könnte verursacht werden, wenn das objekt beim aufruf noch nicht zerstörbar ist? hat das etwas mit exceptions zu tun?

Dein ursprüngliche, "einfache" Implementierung ist sowieso vollkommen defekt. Zum Einen kommt sie mit verschiedenen size Größen zurecht. Zum Anderen sind beim Aufruf aus dem CopyCtor heraus weder array noch size initialisiert.

Du könntest sowas verwenden. Ich habe den operator= gleich mit korrigiert.

Vector(const Vector& src) : array(new double[src.size]), size(src.size)
{
   std::copy(src.array, src.array+size, array);
}
    
void Swap(Vector& src)
{
   std::swap(array, src.array);
   std::swap(size, src.size);
}
    
Vector& operator =  (const Vector& a)
{
    Vector tmp(a);
    Swap(tmp);
    return *this;
}

hier statt Swap kann man es eigentlich auch kopieren, schliesslich es geht um ein temp var, richtig?

hier statt Swap kann man es eigentlich auch kopieren, schliesslich es geht um ein temp var, richtig?

Falls du damit meinst, ob man die Vertauschung durch einfache Zuweisungen ersetzen kann: Nein. Es ist wichtig, dass der "alte" Inhalt des Objekts in der lokalen Variablen landet, damit dieser am Ende des Zuweisungsoperators ordentlich entsorgt wird.

Dein ursprüngliche, "einfache" Implementierung ist sowieso vollkommen defekt.

Es war zwar nicht meine, aber ich sehe es ein.

camper schrieb:

Zum Einen kommt sie mit verschiedenen size Größen zurecht.

Kommt sie doch gar nicht

camper schrieb:

Zum Anderen sind beim Aufruf aus dem CopyCtor heraus weder array noch size initialisiert.

Ja stimmt; das habe ich jetzt verstanden. Außerdem müssen beim Zuweisungsoperator Dinge beachtet werden, die beim Kopierkonstruktor keine Rolle spielen.

netrobot schrieb:

hier statt Swap kann man es eigentlich auch kopieren, schliesslich es geht um ein temp var, richtig?

Kopieren tut hier der Kopierkonstruktor, aber nur in eine temp var. Swap vertauscht dann den Inhalt mit dem des aktuellen Objekts (ohne alle Werte einzeln vertauschen zu müssen).

netrobot schrieb:

hier statt Swap kann man es eigentlich auch kopieren, schliesslich es geht um ein temp var, richtig?

Falls du damit meinst, ob man die Vertauschung durch einfache Zuweisungen ersetzen kann: Nein. Es ist wichtig, dass der "alte" Inhalt des Objekts in der lokalen Variablen landet, damit dieser am Ende des Zuweisungsoperators ordentlich entsorgt wird.

hier tmp ist lokal erzeugt, dann der Inhalt wird mit aktuellem object umgetauscht, tmp ist nachher erstört worden, dann wieso muss man die beiden swappen, tmp ist sowieso nicht mehr da.