#include <iostream>
using namespace std;

class Person
{
public :
   Person(){
      cout<<"call Person Ctor"<<endl;
   }
   virtual ~Person(){
      cout<<"call Person DCtor"<<endl;
   }
   Person( const Person & s)
   {
        cout<<"call Person Copy Ctor"<<endl;
   }
};

Student.hxx

#include "Person.hxx"

class Student : public Person
{
public :
   Student(){
      cout<<"call Student Ctor"<<endl;
   }
   virtual ~Student(){
      cout<<"call Student DCtor"<<endl;
   }
   Student( const Student  &s)
   {
        cout<<"call Student Copy Ctor"<<endl;
   }
};

main.cpp
#include "Student.hxx"

Student showStudent(Student a)
{
    return a;
}
void main()
{
   Student aStudent;
  Student b =  showStudent(aStudent);
   cin.get();
}

Das Ergebnis:

call Person Ctor     //erzeugen aStudent
call Student Ctor    //erzeugen aStudent
call Person Ctor     //erzeugen a
call Student Copy Ctor //Student a = aStudent
call Person Ctor       //return a
call Student Copy Ctor //Student b = a
call Student DCtor     //delete a
call Person DCtor      //delete Base "von a"

call Student DCtor    //delete b
call Person DCtor     //delete Base "von b"
call Student DCtor    //delete aStudent
call Person DCtor     //delete Base von "aStudent"

Aber bei Student a = aStudent, wird nur Copy Ctor aufgerufen? wieso nicht Constructor von Person dann von Student?

Aber bei Student a = aStudent, wird nur Copy Ctor aufgerufen? wieso nicht Constructor von Person dann von Student?

Um ein Objekt zu konstruieren, benötigst du einen Ctor-Aufruf (mal abgesehen von den indirekten Aufrufen zum Aufbau der Teilobjekte (Basis/Member). D.h. das Objekt wird entweder per Copy-Ctor, Default-Ctor oder eigenen Ctor erzeugt und ist dann komplett.

Hallo,
der Copy Ctor spielt in deinem Programm nur beim Funktionsaufruf von showStudent und bei dem Rückgabewert eine Rolle. Danach kommt allerdings der Zuweisungsoperator ins Spiel (das '='), welcher bei deinen Klassen nicht überladen
ist und du deshalb auch keine Ausgabe erhalten kannst.

Ein Zuweisungsoperator wird hier niergends aufgerufen. X x = y; ruft keinen Zuweisungsop auf. Auch wenn hier ein =-Zeichen steht. Siehe dazu:
http://fara.cs.uni-potsdam.de/~kaufmann/?page=GenCppFaqs&faq=copyvsdirect#Answ

Aber bei Student a = aStudent, wird nur Copy Ctor aufgerufen? wieso nicht Constructor von Person dann von Student?

Hier wird der Copy-Ctor von Student aufgerufen, welcher, da du ihn so implementiert hast, den Standard-Ctor von Person aufruft.
Die Ausgabe für Student a = aStudent sollte also sein:
call Person Ctor
class Student Copy Ctor

Besser wäre es, wenn du den Copy-Ctor von Student so implementieren würdest:

Student( const Student  &s)
    : Person(s)
{
    cout<<"call Student Copy Ctor"<<endl;
}

So verhält er sich dann auch wie ein automatisch generierter. Er ruft als den Copy-Ctor der Basisklasse auf.

Student( const Student &s)
: Person(s)
{
cout<<"call Student Copy Ctor"<<endl;
}

ja, das ist besser, es ruft zwar einen CTor mehr(copy CTor von Person),aber danach a und aStudent sind völlig identisch

ja, das ist besser, es ruft zwar einen CTor mehr(copy CTor von Person),aber danach a und aStudent sind völlig identisch

Wieso "mehr"? Diese Variante ruft lediglich einen anderen Ctor von Person auf als der aus deinem ursprünglichen Beispiel (statt des Default-Ctors den Copy-Ctor).

die beiden sind vom aussehen her also identisch...

Ja
(genau genommen ist Copy-Ctor nur eine Sonderbezeichnung für den Parameter-Ctor, der mit einem einzelnen "const 'eigene_klasse'&" aufgerufen werden kann)

netrobot schrieb:

ja, das ist besser, es ruft zwar einen CTor mehr(copy CTor von Person),aber danach a und aStudent sind völlig identisch

Wieso "mehr"? Diese Variante ruft lediglich einen anderen Ctor von Person auf als der aus deinem ursprünglichen Beispiel (statt des Default-Ctors den Copy-Ctor).

nehmen wir an, in Ctor von Student schreibe ich nicht :Person(s)
bei

Student a = aStudent

aStudent hat 2 Teile, der 1. von Person; der 2. von Student selber, falls der 1. Teil in aStudent was geändert wurde,

Student a = aStudent

a hat nur den originalen Person-Teil, d.h. a und aStudent sind nicht identisch.