// Listing 17.4 Virtueller Kopierkonstruktor

 #include <iostream>

 class Mammal

 {

 public:

     Mammal():itsAge(1) { std::cout << "Mammal-Konstruktor...\n"; }

     virtual ~Mammal() { std::cout << "Mammal-Destruktor...\n"; }

     Mammal (const Mammal & rhs);

     virtual void Speak() const { std::cout << "Mammal gib Laut!\n"; }

     virtual Mammal* Clone() { return new Mammal(*this); }

     int GetAge()const { return itsAge; }

 protected:

     int itsAge; //<-- HIER ganz normale Variable, kein Zeiger!

 };

 Mammal::Mammal (const Mammal & rhs):itsAge(rhs.GetAge()) /*Was soll das hier? Muss man nun auch bei ganz normalen Variablen schon Kopierkonstruktoren einsetzen? Das wäre mit aber ganze neu, und verwirrt mich deshalb nun so sehr. Ist das jetzt echt normal das man bei ganz normalen Variablen (also bei "nicht-Zeigern") schon nen Kopierkonstruktor braucht? Ich hab immer gedacht nur bei Zeigern aufm Heap! Mhh?*/ 

 {

     std::cout << "Mammal-Kopierkonstruktor...\n";

 }

 class Dog : public Mammal

 {

 public:

     Dog() { std::cout << "Dog-Konstruktor...\n"; }

     virtual ~Dog() { std::cout << "Dog-Destruktor...\n"; }

     Dog (const Dog & rhs);

     void Speak()const { std::cout << "Wuff!\n"; }

     virtual Mammal* Clone() { return new Dog(*this); }

 };

 Dog::Dog(const Dog & rhs):

 Mammal(rhs)

 {

     std::cout << "Dog-Kopierkonstruktor...\n";

 }

 class Cat : public Mammal

 {

 public:

     Cat() { std::cout << "Cat-Konstruktor...\n"; }

     virtual ~Cat() { std::cout << "Cat-Destruktor...\n"; }

     Cat (const Cat &);

     void Speak()const { std::cout << "Miau!\n"; }

     virtual Mammal* Clone() { return new Cat(*this); }

 };

 Cat::Cat(const Cat & rhs):

 Mammal(rhs)

 {

     std::cout << "Cat-Kopierkonstruktor...\n";

 }

 enum ANIMALS { MAMMAL, DOG, CAT};

 const int NumAnimalTypes = 3;

 int main()

 {

     Mammal *theArray[NumAnimalTypes];

     Mammal* ptr;

     int choice,i;

     for (i = 0; i<NumAnimalTypes; i++)

     {

         std::cout << "(1)Hund (2)Katze (3)Säugetier: ";

         std::cin >> choice;

         switch (choice)

         {

         case DOG:

             ptr = new Dog;

             break;

         case CAT:

             ptr = new Cat;

             break;

         default:

             ptr = new Mammal;

             break;

         }

         theArray[i] = ptr;

     }

     Mammal *OtherArray[NumAnimalTypes];

     for (i=0;i<NumAnimalTypes;i++)

     {

         theArray[i]->Speak();

         OtherArray[i] = theArray[i]->Clone();

     }

     for (i=0;i<NumAnimalTypes;i++)

         OtherArray[i]->Speak();

     return 0;

 }

Bitte klärt mich auf. Dankeschön schon mal im Voraus.

Wenn man hingegen eine *Kopie* eines Objekts erzeugen will, dann wird der Kopierkonstruktor aufgerufen. Also hier:

class Foo {};

// ...

Foo x;
Foo y = x; // Hier wird der Kopierkonstruktor von 'Foo' aufgerufen.

Foo* z = &x; // Hier nicht.

...
Mammal::Mammal (const Mammal & rhs):itsAge(rhs.GetAge())
...

Weil "itsAge" ist doch gar kein Zeiger.
Dankeschön schon mal im Voraus.

Ja okay, aber ist das hier nun unsinnig oder ist das wichtig? [Zeile 35]

...
Mammal::Mammal (const Mammal & rhs):itsAge(rhs.GetAge())
...

Weil "itsAge" ist doch gar kein Zeiger.

Ja, wir wollen den Wert doch auch *kopieren*! Wieso sollte das denn ein Zeiger sein?

Also, ist richtig so. Wir kopieren das Alter der alten Instanz in das der neuen Instanz.

...
Mammal::Mammal (const Mammal & rhs):itsAge(rhs.GetAge())
...

nicht falsch, aber unnötig?
In meinem Buch steht:

Der Standardkopierkonstruktor kopiert einfach jede Elementvariable von dem als Paramter übergebenem Objekt in die Elementvariablen des neuen Objekts. Man spricht hier von einer elementweisen (oder flachen) Kopie. Obwohl das bei den meisetn Elementvariablen durchaus funktioniert, klappt das bei Elementvariablen, die Zeiger auf Objekte im Heap sind, schon nicht mehr wie beabsichtigt.
Eine flache oder elementweise Kopier kopiert die genauen Werte der Elementvariablen des einen Objekts in ein anderes Objekt. Zeiger in beiden Objekten verweisen letztendlich auf denselben Speicher. eine tiefe Kopie überträgt andererseits die auf dem Heap reservierten Werte in neu zugewiesenen Speicher.

Das hab ich mit den andauerden "Zeigern" gemeint. Weißt was ich mein? Soll ich in Zukunft trotzdem einfach immer alle Elementvariablen in den Kopierkonstruktor mitreinschreiben? Oder jetzt doch nur die Zeiger die auf Speicher auf dem Heap verweisen? Oder doch alle? Dankeschön schon mal im Voraus.

Ja aber es gibt doch auch einen "Standardkopierkonstruktor", somit ist doch

...
Mammal::Mammal (const Mammal & rhs):itsAge(rhs.GetAge())
...

nicht falsch, aber unnötig?

Ach so. Jetzt verstehe ich. Ja, Du hast recht, er ist natürlich in diesem Fall unnötig und kann getrost weggelassen werden. Und Du hast recht, ein Fall, in dem er nötig ist, tritt auf, wenn man sich um die manuelle Verwaltung von Heapspeicher kümmern muss.

Sorry, habe einfach zu kurz gedacht.