#include <algorithm> //für swap
    using namespace std;

    class Array
    {
    private:
      unsigned length; //keine negative Länge
      int* value;

      void copy(int* value, unsigned length)
      {
        for(unsigned i=0; i<length; ++i)
        {
          this->value[i]=value[i];
          //this-> weil der Parameter value verdeckt this->value
          //mittels this-> sagen wir dem Compiler welches value wir wollen
        }
      }

    public:
      Array(int* value, unsigned length)
      : length(length), value(new int[length])
      {
        copy(value, length);
      }

      Array(Array const& other)
      : length(other.length), value(new int[other.length]) // <-- !!!
      {
        copy(other.value, other.length); // <-- !!!
      }

      Array const& operator=(Array const& other)
      {
        Array temp(other);  //benutze CopyCtor um eine Kopie zu erstellen
        swap(temp);         //tausche Member mit der Kopie aus
        return *this;
      }                     //Kopie wird zerstört

      ~Array()
      {
        delete [] value;
      }

      void swap(Array& other)
      {
        swap(value, other.value);
        swap(length, other.length);
        //swap funktioniert wie unser tausche - allerdings für jeden Variablentyp
      }
    };

Warum geht in den Zeilen 28 u. 30 "other.length" und "other.value"?! Weil "length" und "value" sind doch private!? Kann mir jemand helfen?

MfG
Stromberg

Warum geht in den Zeilen 28 u. 30 "other.length" und "other.value"?!

Aber other ist auch eine Instanz der Array-Klasse, damit ist das in Ordnung.

Warum geht in den Zeilen 28 u. 30 "other.length" und "other.value"?! Weil "length" und "value" sind doch private!? Kann mir jemand helfen?

In Methoden einer Klasse kannst Du immer auf private-Elemente zugreifen (das gilt nicht nur für this!).

private bedeutet das die dort deklarierten Member nach außen hin nicht sichtbar sind. Du befindest dich aber innerhalb dieser Klasse. private arbeitet nicht auf Instanzebene.
siehe auch im Standard 11.1
[edit]Bin ich aber heute spät dran. [edit]

#include <iostream>
using namespace std;

class Array
{
    public:
    Array(const int *array,unsigned int length_);
    Array(const Array &rhs);
    ~Array();
    void copy(const int *array, int length_);
    void operator=(Array const &other);

    private:
    int *m_value;
    unsigned int m_length;
};

Array::Array(const int *array, unsigned int length_)
:m_value(new int[length_]), m_length(length_)
{
    copy(array,length_);
}

Array::Array(const Array &rhs)
:m_value(new int[rhs.m_length]), m_length(rhs.m_length)
{
    copy(rhs.m_value, m_length);
}

Array::~Array()
{
    delete [] m_value;
}

void Array::copy(const int *array, int length)
{
    for (int i=0;i<length;i++)
    {
        m_value[i]=array[i];
    }
}

void Array::operator= (const Array &other)
{
    delete m_value;
    m_value=new int[other.m_length];
    m_length=other.m_length;
    copy(other.m_value, m_length);
}

int main()
{

    return 0;
}

Muss man bei "operator=" unbedingt was zurückgeben? Und geht das so wie ichs mach oder is es kacke?

MfG
Stromberg

usw ... ^^

usw ... ^^

Und inwiefern beantwortet das Strombergs letzte Frage?
Davon ab dass Dein operator= defekt ist.

MfG
Stromberg

Aber was ich an dem "swap" noch merkwürdig finde, eigentlich werden da doch zwei Täusche (gibts des Wort?) durchgeführt.
1mal von klass A -> B, und dann noch mal von Klasse B -> A. Aber es reicht doch einer von den beiden, den anderen braucht man doch nicht und ist zeitverschwendung?! Oder versteh ich da wieder was falsch? Vll. sollt man einen Tausch machen der nur von der einen Klasse in die andere schreibt?

Das Wort "tausche" impliziert, dass A hinterher den Inhalt von B und B den Inhalt von A hat. Sonst hieße es "kopiere"

Der Sinn des ganzen ist, dass eins der beiden getauschten Objekte das temporäre Objekt ist, welches unmittelbar nach dem Tausch gelöscht wird. Damit räumt der Destruktor von temp automatisch die Daten ab, die sich zuvor noch in *this befunden haben. Du machst quasi:

1. Erzeuge temp. Objekt als Kopie von der Quelle (erzeugen eines neuen Array mit bereits existierenden Funktionen)
2. Tausche Inhalt von temp. Objekt mit Inhalt von *this (das geht sehr schnell und danach beinhaltet *this eine Kopie der Quelle, und das temp. Objekt den Müll der vorher in *this stand)
3. Lösche temp. Objekt (damit wird der Müll, der vorher in *this stand, ordentlich abgebaut)

LordJaxom schrieb:

...und das temp. Objekt den Müll der vorher in *this stand...

und da hab ich mir gedacht, es reicht doch wenn man das Zeug von "temp" einfach in *this reinstecken....ist ja nur Zeit verschwendung das alte Zeug von "*this" in temp zu haun!
Aber das hier erklärt dann wieder alles:

LordJaxom schrieb:

3. Lösche temp. Objekt (damit wird der Müll, der vorher in *this stand, ordentlich abgebaut)

Also ist es doch sinvoll 2 mal zu tauschen einmal von temp nach *this und umgekehrt.
Dankeschön.

MfG
Stromberg

MfG
Stromberg

Äh udn noch was, bei den Zeigern, da tauscht swap doch einfach nur die Adressen oder?

Gehen wir nochmal in das Detail. Swap dient dazu Exceptionneutral zu sein. Das bedeutet das ein Objekt entweder ganz oder garnicht kopiert wird und in einen konsistenten Zustand bleibt (Sprich im Fehlerfall DARF kein inkonsistenter Zwischenstand eintreten).

Dies kannst du nicht bei einer direkten Zuweisung garantieren, da beim Aufruf des Zuweisungsoperators eine Exception eintreten kann, und das Objekt dann ggf. schon in Teilen überschrieben ist.

Bei einem Tausch von Zeigern kann aber keine Exception eintreten. Daher diese drei Schritte (Wenn ein Fehler bei der Anlage eintritt, bleibt der alte Stand erhalten, und es tritt kein inkonsistenter Zwischenstand ein...).

cu André

MfG
Stromberg

Innerhalb der Methoden eines Objekts hat man Zugriff auf private Elemente von anderen Objekten und oder *this. Innerhalb einer Klasse hat man ebenso Zugriff auf private Elemente. Nur außerhalb einer Klasse oder eines Objekts hat man nur Zugriff auf öffentliche (public) Elemente.

Oder kann man da noch an der Formulierung feilen???

MfG
Stromberg

Du hast es also bei deiner Formulierung irgendwie "doppel gemoppelt" beschrieben.

Hallo,

private bedeutet das die dort deklarierten Member nach außen hin nicht sichtbar sind....[edit]

Das ist bestimmt richtig gemeint, führt aber leider auf die falsche Fährte, denn sichtbar sind auch private-Member ... aber eben nicht zugreifbar.
Die Sichbarkeit kann z.B. zu Problemen mit "ungewollten Overloads" führen...

Gruß,

Simon2.