#include<iostream>
#include<string>

using namespace std;

class Counter
{
      public:
             Counter();
             Counter(const Counter &);
             ~Counter(){}
             int GetItsVal() const {return itsVal; }
             void SetItsVal(int x) { itsVal = x; }
             Counter operator++ ();
      private:
              int itsVal;
};

Counter::Counter():itsVal(0)
{};

Counter::Counter(const Counter &rhs)
{
    cout<<"Aufruf des Kopierkonstruktors\n";
}

Counter Counter::operator++()
{
        ++itsVal;
        Counter temp;
        temp.SetItsVal(itsVal);
        return temp;
};
/*
Counter funktionone(const Counter tmp)
{
        return tmp;
}
*/

Counter funktion()
{
        Counter tmp;
        tmp.SetItsVal(4);
        return tmp;
}

int main()
{   
    Counter test; 

    cout<<test.GetItsVal()<<endl;
    test.SetItsVal(5);
    cout<<test.GetItsVal()<<endl;

    Counter a = ++test;
    Counter b = funktionone(test);
    Counter c = funktion();

    cout<<test.GetItsVal()<<endl;

    getchar();    
    return 0;
}

Der Kopierkonstrukor wird bei diesem Programm nur bei Aufruf und bei der Zuweisung des Rückgabewertes von "funktionone" aufgerufen. Das verstehe ich auch. Aber warum wird der Kopierkonstrukor nicht bei der Zuweisung des Rückgabewertes von "funktion" aufgerufen? Schließlich gibt "funktion" doch auch ein Counter-Objekt zurück, welches dann "a" zugewiesen wird, was meiner Meinung nach soviel heißt wie, kopiere die Inhalte der Elementvariablen von dem zurückgegebenen Counter-Objekt in die Elementvariablen von "a". Oder sehe ich das falsch?

Die gleiche Frage stelle ich mir bei der Definition von "operator++()", da der doch auch ein Counter-Objekt zurückgibt.

Vielen Dank für die Antworten!

Gruß Pete

a) den Default-Konstruktor: Counter()
b) den Kopierkonstruktor: Counter(const Counter&)
c) den Destruktor: ~Counter()
und
d) den Zuweisungsoperator: Counter& operator=(const Counter&);

und versehe sie mit Ausgabefunktionen. Dann wird einem so manches klarer.

Ich habe mir schon so einige seg-faults eingefangen, weil ich in meinen Klassen Pointerverwaltung und Speicherfreigabe ganz elegant lösen wollte und mir beim Kopieren und Zuweisen die Objekte "zerschossen" wurden

Grüße... Heiko

Ich habe das Gefühl, dass das etwas damit zu tun hat, dass das Counter-Objekt "tmp" welches in der Funktion "funktion" erstellt wird nach Beendigung der Funktion nicht mehr existiert, aber die Elementvariable "itsVal" des Counter-Objekts "c" hat danach ja den Wert 4, somit muss diese ja vom dem Objekt "tmp" kopiert worden sein nur wird kein Kopierkonstruktor aufgerufen, was ich nicht verstehe.

Vielen Dank!

Gruß Pete