operator + überschreiben

Braunstein

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;
}

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);
}

rapso

noch mehr sexy ist, wenn dein operator+ statt einem vector z.b. vectoradd zurueckgibt. dann brauchst du noch einen entsprechenden operator= und copy-ctor die beide vectoradd akzeptieren.
beim kopieren setzt du im aktuellen objekt den ptr auf das array der quelle und in dem quell-objekt setzt du den zeiger auf auf null (darfst natuerlich das quellobjekt nicht per constreference sondern nur reference bekommen).

camper

lsg schrieb:

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?

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?

MFK

lsg schrieb:

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.

ok. danke für die lehre.

camper

lsg schrieb:

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.

netrobot

Braunstein schrieb:

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?

MFK

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.

camper schrieb:

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

MFK schrieb:

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.

Braunstein

Wenn du array zuweist, überschreibst du den alten Pointer und hast somit keine Möglichkeit mehr diesen Speicherbereich freizugeben. Beim Swap steckt genau dieser alte Speicherbereich dann in der temp-Variable und wird von dessen Destruktor am Ende des CopyCTors entsorgt.