Bin mal auf euer Forum gestoßen, was mir grade recht kam, weil ich hier bei meinem Übungsprogramm eine Sache einfach nicht verstehe. Ich hab auch mit der SuFu hier nichts gefunden, was mir meine Frage beantwortet hat.

Also in dem Programm geht es darum, eine Klasse zu verwalten, deren Objekte jeweils ein double Array und die Feldlänge enthalten.
Ich übe gerade generell das Überladen von Operatoren und habe für dieses Programm mal folgende Operatoren überladen:
- Den Zuweisungsoperator
- Subscriptoperator
- Ausgabeoperator
- Inkrementoperator (Postfix und Prefix)

Das Programm funktioniert auch soweit schon, aber eine Sache lässt mir hier keine Ruhe:

Ich weis, dass der Copykonstruktor immer für Ausdrücke wie
Klasse Objekt_2 = Objekt_1
oder
Klasse Objekt_2(Objekt_1)
zuständig ist. Aber für normale Zuweisungen mitten im Programm sollte doch eigentlich ausschließlich der Zuweisungsoperator arbeiten oder?
Die Frage hat sich bei mir aufgetan, als ich bemerkt hab, dass bei einem Ausdruck wie
Objekt2 = Objekt1++;
mein Zuweisungsoperator, dann der ++ Operator, und seltsamerweise davor UND danach auch noch der Copykonstruktor arbeiten. Ist das normal? Und wenn ja, warum muss der Copykonstruktor bei so einer Aktion gleich zweimal einspringen?

Irgendwie komm ich bei der Überlegung nicht weiter - hat hier vielleicht jemand eine Antwort? Ich hab nämlich eher das Gefühl, dass hier eher in dem Programm was schief läuft, denn den Copykonstruktor gleich zweimal für eine Aktion aufzurufen, für die erdoch eigentlich nicht zuständig ist (?), wäre doch eher unnötig.

Irgendwie hab ichs nicht geschafft hier Spoiler reinzubekommen - darum, so leids mir tut, post ich mal den code direkt hier rein...die Kommentare sind für euch evtl überflüssig aber nja - ich mahc das noch ent wirklich lang

safar.h:

#ifndef SAFAR_H_INCLUDED
#define SAFAR_H_INCLUDED

#include <iostream>

using namespace std;

class Array
{
	private:
		double *array;								//	Adressen der gespeicherten Daten im Array - der einzelnen Objekte
		int size;							//	Größe des Arrays

	public:
		Array(int size = 0);						//	Konstruktor - kann Array auch mit gegebenen Defaultwerten inizialisieren
		Array(const Array &original);				//	Copykonstruktor

		~Array();									//	Destruktor

		Array operator=(const Array &array_r);			//	Überladung des Zuweisungsoperators
//		Array operator+=(const Array &ar_r);		//	Überladung des += Operators
		Array operator++();							//	Überladung des ++ Operators als Präfix
		Array operator++(int);						//	Überladung des ++ Operators als Postfix

		double & operator[](const int size);				//	Überladung des Subscriptoperators

		friend ostream &operator<<(ostream &os, const Array &array);	//	Überladung des Ausgabeoperators
};

#endif // SAFAR_H_INCLUDED

safar.cpp:

#include <iostream>
#include "safar.h"

using namespace std;

///////////////////////////////////////////////////////////////////////////////////////////////
//	Konstruktoren
/////////////////////////////////////////////////////////////////////////////////////////////

//	Konstruktor mit Defaultwerten zu Inizialisierung des Arrays:
Array::Array(const int size)
{
	if(size > 0)
	{
		this->size = size;
		this->array = new double[size];				//	[], weil hier ein numerischer Wert benötigt wird, und KEIN Ausdruck!

		for(int i = 0; i < size; i++)
		{
			this->array[i] = 0.0;
		}
	}
	else
	{
		this->array = NULL;
		this->size = 0;
	}
}

//	Copykonstruktor:
Array::Array(const Array &original)
{
	if(original.size > 0)
	{
		this->array = new double[original.size];
		this->size = original.size;
//	memcpy kopiert den als Parameter 2 angegebenen Speicherbereich samt enthaltener Daten an den in PArameter 1 angegebenen Zielbereich.
//	Parameter 3 ist die zu kopierende Größe in Byte und muss zur Verhinderung von Überlappungen der SPeicherbereiche angegeben werden; memcpy erfordert die Inkludierung von string.h:
		memcpy(this->array, original.array, this->size * sizeof(double));
	}
	else
	{
		this->array = NULL;
		this->size = 0;
	}

	cout << "\nCopyconstruktor...\n";
}

///////////////////////////////////////////////////////////////////////////////////////////////
//	Destruktor
/////////////////////////////////////////////////////////////////////////////////////////////

Array::~Array()
{
	if(this->array != NULL)
	{
		delete []this->array;
	}
	cout << "\nDestruct...\n";
}

///////////////////////////////////////////////////////////////////////////////////////////////
//	Operatorfunktionen
/////////////////////////////////////////////////////////////////////////////////////////////

//	Überladung des Zuweisungsoperators:
Array Array::operator=(const Array &array_r)
{
	if(this == &array_r)
	{
		return *this;
	}

	if(&array_r != NULL)
	{
		if(this->array != NULL)
		{
			delete []this->array;
		}

		this->size = array_r.size;
		this->array = new double[this->size];
		memcpy(this->array, array_r.array, this->size * sizeof(double));
	}
	else
	{
		this->array = NULL;
		this->size = 0;
	}

	cout << "\nZuweisungsoperator...\n";
	return *this;
}

//	Überladung des ++ Operators als Prefix (++Operand):
Array Array::operator++()
{
	for(int i = 0; i < this->size; i++)
	{
		++this->array[i];
	}

	cout << "\nPREfix...\n";
	return *this;
}

//	Überladung des ++ Operators als Postfix (Operand++):

Array Array::operator++(int)
{
	Array tmp = *this;
	for(int i = 0; i < this->size; i++)
	{
		tmp.array[i]++;
	}

	cout << "\nPOSTfix...\n";
	return tmp;
}

//	Überladung des Subscriptoperators [] zur Überprüfung auf Bereichsüberschreitung beim Indizieren eines Arrays:
double & Array::operator[](const int i)
{
	static double overFlow;

	if((i >= 0) && (i < this->size))
	{
		return array[i];
	}
	else
	{
		return overFlow;
	}
}

//	Überladung << Operators zur benutzerdefinierten Ausgabe auf std::cout:
ostream &operator<<(ostream &os, const Array &array)
{
	cout << "\nInhalt von Array:\n";
	for(int i = 0; i < array.size; i++)
	{
		os << "[" << i << "]:  " << array.array[i] << ' ';
	}

	return os;
}

safar_main.cpp:

#include <iostream>
#include "safar.h"

using namespace std;

int main()
{
	Array a1(3);
	Array a2;

	a1[0] = 1; a1[1] = 1.5; a1[2] = 2;

	cout << "\na1:\t" << a1;
	cout << "\na2:\t" << a2;

	a2 = a1++;

	cout << "\na1:\t" << a1;
	cout << "\na2:\t" << a2;

	a1 = ++a2;

	cout << "\na1:\t" << a1;
	cout << "\na2:\t" << a2;

	Array a3 = a2;
	a2 = a1;

	return 0;
}

Wie gesagt, das Ding funktioniert scheinbar soweit - zumindest tut es, was es tun soll. Mir geht es hierbei auch nicht darum, das Programm effizienter oder lesbarer zu schreiben - ich bin mir nur nicht sicher, warum dieses Phänomen mit dem Copykonstruktor dort auftritt, wo ich nicht damit gerechnet hätte.

Danke euch jetzt schonmal für eure Hilfe,
Schönen Abend noch

Hinweis:
Überladung von Operatoren (Teil 1)
Überladung von Operatoren (Teil 2)
Überladung von Operatoren (Teil 3)

Grüssli

Wenn nämlich auch bei Verwendung des this Pointers der Copykonstruktor einspringen muss - wenn das so stimmt, dann würde ich auch verstehen, dass nur deshalb auch der Destruktor an der Stelle gleich zweimal arbeiten muss. Lansgsam kommts mir so vor, als hätt ich die Vorgänge in dem Programm doppelt und dreifach ausprogrammiert...

Einen std::vector könnte (sollte) man auch benutzen. Aber ich gehe jetzt einfach mal davon aus, dass Du üben/experimentieren willst.

Dein postfix operator++ ist falsch. Das Ding sollte eine Kopie des alten Werts zurück geben. Du modifizierst stattdessen das, was du zurück gibst.

BTW: Die Zahl der copy-ctor Aufrufe ist Sache der Implemtierung. Der C++ Standard gibt allerdings Schranken vor. Eine moderne Implementierung (im release-Modus) kann einige überflüssige Kopien wegoptimieren ("copy elision").

kk