Virtual tabele and _vptr

class Base
{
public:
virtual void function1() { cout << "Base :: function1()\n"; }
virtual void function2() { cout << "Base :: function2()\n"; }
virtual ~Base() { cout << "Base destructor" << endl; }
Base() { cout << "Base constructor" << endl; }
};
class D1 : public Base
{
public:
~D1() { cout << "Desturctor of D1" << endl; }
D1() { cout << "Constructor of D1" << endl; }
virtual void function1() { cout << "D1 :: function1()\n"; }
};
class D2 : public D1
{
public:
~D2() { cout << "Desturctor of D2" << endl; }
D2() { cout << "Constructor of D2" << endl; }
//virtual void function2() { cout << "D2 :: function2()\n"; }
};
class D3 : public D2
{
public:
~D3() { cout << "Desturctor of D3" << endl; }
D3() { cout << "Constructor of D3" << endl; }
virtual void function2() { cout << "D3 :: function2()\n"; }
};

int main()
{
D3 *d = new D3;
Base *b = d;
d->function1();
d->function2();
delete (;
return (0);
}

• De ce nu trebuie sa fie virtuali si destructorii din clasele derivate? Daca fac un obiect de tip D3 cum stie sa ajunga la D2, D1 fara ca acesita sa fie virtuali?
  
  
• De ce nu reuseste sa fie invovat destructorul lui D3 daca destructorul din clasa de baza nu este virtual ?  In mod normal in exemplul de mai sus Base* b poniteaza spre vTabele a lui D3, in D3 (cum este si in imaginea din link-ul de mai sus) exista destructorul sau salvat, asadar de ce nu reuseste sa-l invoce?

D3* d3 = new D3;
D2* ptrd2 = d3;
d3->function1();
delete ptrd2;

Edited by dani.user, 15 January 2018 - 17:25.

Edited by virgil94, 15 January 2018 - 17:35.

dani.user, on 15 ianuarie 2018 - 17:39, said:

[color=#ff0000][b]vtable for Derived:[/b][/color]
  .quad 0
  .quad typeinfo for Derived
  .quad Derived::foo()
typeinfo for Derived:
  .quad vtable for __cxxabiv1::__si_class_type_info+16
  .quad typeinfo name for Derived
  .quad typeinfo for Base
typeinfo name for Derived:
  .string "7Derived"
typeinfo for Base:
  .quad vtable for __cxxabiv1::__class_type_info+16
  .quad typeinfo name for Base
typeinfo name for Base:
  .string "4Base"

#include <iostream>
using namespace std;
class a {
public:
virtual void test() {}
};
class b {
public:
virtual void test2() {}
};
class c : public a, public b
{
public:
virtual void test33() {}
};
int main()
{
a A;
b B;
c C;
A.test();
B.test2();
C.test33();
cout << sizeof(c);
return 0;
}

#include <iostream>

class A {
public:
	virtual void test() {}
};

class B {
public:
	virtual void test2() {}
};

class C : public A, public B {
public:
	virtual void test33() {}
};

int main()
{
	A a;
	B b;
	C c;
	a.test();
	b.test2();
	c.test33();

	std::cout << "C e la adresa " << &c << '\n';
	std::cout << "C interpretat ca A ar fi la adresa " << static_cast<A*>(&c) << '\n';
	std::cout << "C interpretat ca B ar fi la adresa " << static_cast<B*>(&c) << '\n';

	std::cout << sizeof(c);
	return 0;
}

Quote

• Fiecare clasa are propriul "virtual table" daca are una sau mai multe functii virtuale definite (asta daca nu decide compilatorul sa faca optimizari).
  
• vptr este pointer ce indentifica o tabela virtuala
  
• tabela virtuala contine pointeri la functii care fac posibila apelarea corecta a metodelor in functie de obiectul instantiat
  
• o data creeata o tabela virtuala pentru o clasa aceasta ramane neschimbata (clasele derivate cel mult vor adauga noi metode in functie de optimizarile compilatorului) si mostenita mai departe.

Base*ptrBase = new Dev;

• De ce in vtable pentru A, B si C destructorii lor sunt multiplicati (pentru A : A::~A , A::~A, acelasi lucru se intampla pentru B si C.
  
• De ce se mostenesc vptr in clasele derivate daca fiecare clasa isi creeaza prorpriul virtual table unde retin tot ce au nevoie referitor la ierarhia de clase?

#include<iostream.h>
class Base
{
public:
virtual void function1() {cout<<"Base :: function1()\n";};
virtual void function2() {cout<<"Base :: function2()\n";};
virtual ~Base(){};
};

class D1: public Base
{
public:
~D1(){};
virtual void function1() { cout<<"D1 :: function1()\n";};
};

class D2: public Base
{
public:
~D2(){};
virtual void function2() { cout<< "D2 :: function2\n";};
};
int main()
{
D1 *d = new D1;;
Base *b = d;
b->function1();
b->function2();
delete (;

return (0);
}
output:
D1 :: function1()
Base :: function2()