#include <iostream.h>
#include <stdlib.h>
#include <string.h>
class Student;
class Person {
public:
Person() {cout << "constructor Person" << endl;}
~Person() {cout<< "destructor Person" << endl;}
};
const Student& returnPerson(const Student& p) {return p;}
class Student : public Person {
public:
Student() {cout << "constructor Student" << endl;}
~Student() {cout << "destructor Student" << endl;}
};
Student returnStudent(Student s) {return s;}
class PhDStudent: public Student {
public:
PhDStudent(){cout << "constructor PhDStudent" << endl;}
~PhDStudent() {cout << "destructor PhDStudent" << endl;}
};
Student returnPhDStudent(Student s)
{
return s;
}
int main(int argc, char* argv[])
{
for (int i=0; i<10; i++)
cout << endl;
PhDStudent laza;
cout << endl;
returnPhDStudent(returnStudent(returnPerson(laza)));
cout << endl;
}
Rezultat u konzoli:
constructor Person
constructor Student
constructor PhDStudent
destructor Student
destructor Person
destructor Student
destructor Person
destructor Student
destructor Person
destructor PhDStudent
destructor Student
destructor Person
Prva tri konstruktora i poslednja tri destruktora su jasni. Ali: Zašto šest destruktora, bez ijednog konstruktora?
const Student& returnPerson(const Student& p) {return p;} - Šta ampersendi (tj. referenciranje) menja u pogledu izvršavanja konstruktora?
Problem broj dva:
#include <iostream.h>
class Klasa {
public:
Klasa() {cout << "Konstruktor klase Klasa \n";}
~Klasa() {cout << "Destruktor klase Klasa \n";}
};
class Osnovna {
public:
Osnovna() {cout << "Konstruktor osnovne klase \n" << endl;}
~Osnovna() {cout << "Destruktor osnovne klase \n" << endl;}
};
class Izvedena : public Osnovna {
private:
Klasa x;
public:
Izvedena() {cout << "Konstruktor izvedene klase" << endl;;}
~Izvedena() {cout << "Destruktor izvedene klase" << endl;}
};
void main()
{
Izvedena d;
}
Zašto se konstruktori izvršavaju redosledom: Osnovna, Klasa pa tek onda Izvedena? Zar nije logičnije da ide konstruktor osnovne, pa onda izvedene, pa tek na kraju klase Klasa?
Problem broj tri:
#include <iostream.h>
class Osnovna {
public:
virtual void f() {
cout << "Funkcija OSNOVNE klase \n";
}
};
class Izvedena : public Osnovna {
public:
void f() {
cout << "Funkcija IZVEDENE klase \n";
}
};
void g1(Osnovna b) {b.f();}
void g2(Osnovna *pb) {pb->f();}
void g3(Osnovna &rb) {rb.f();}
void main()
{
for (int i=0;i<10; i++)
cout << endl;
Izvedena d;
g1(d); //1. poziva se Osnovna::f()
g2(&d); //2. poziva se Izvedena::f()
g3(d); //3. poziva se Izvedena::f()
cout << endl;
Osnovna *pb = new Izvedena; pb->f(); //4. poziva se Izvedena::f()
Osnovna &rb=d; rb.f(); //5. poziva se Izvedena::f()
Osnovna b=d; b.f(); //6. poziva se Osnovna::f()
delete pb; pb=&b; pb->f(); //7. poziva se Osnovna::f()
}
Šta mu dođe &rb=d?
Poslednji red: pb je pokazivač tipa Osnovna, ono našta pokazuje se briše, i onda pokazuje na b koji opet pokazuje (ili je možda ispravnije reći je isto što i?) na d. Zašto se onda poziva Osnovna::f()?
Hvala na vremenu! ;)