离过年还有一周半,加紧完成自己的计划,自律==自由!
学习到C++多态,离不开的就是虚函数/纯虚函数/虚析构函数,虚函数与纯虚函数的核心就是VFT和VFT*,这点原理不再多述
比较好的博客罗列如下:
【转】:https://blog.csdn.net/yusiguyuan/article/details/12676177
【转】:https://blog.csdn.net/hackbuteer1/article/details/7558868
对于将基类的析构函数用virtual关键字声明,我个人的理解如下:
个人理解在基类中将析构函数声明为虚函数和多态的原理一致
而且只用在基类中声明虚函数使用virtual关键字,在子类以及孙类以及以后都不用再写virtual关键字,因为它们都是虚拟的
将基类的析构函数声明为virtual后,构造派生类对象时过程如下:
1.构造基类对象,先构造VFT及VFT*,记录基类虚析构函数
2.构造子类对象(除基类对象剩余部分),更新VFT, 将其中的虚析构函数换成子类的虚析构函数
所以当基类指针指向派生类对象时, 并delete,调的就是派生类的析构函数
这种过程对于多重继承也适用,因为每继承一次, 头部的VFT*指向的VFT就会更新一次
需要注意的是, 在多态行为中, 一个对象只有一个VFT和VFT*
代码如下:
注意到代码中有调用delete函数的三个重载版本,用条件编译宏控制,构造了一个多重继承场景,最后将孙类实例的地址传给基类指针,由于析构函数是virtual的,所以孙类实例的VFT始终是孙类的析构函数,不管怎么样都会从孙类的析构函数开始调用,保证没有内存泄露
root@ubuntu:/lianxi/lianxi_c++/chapter11# g++ sample11.4_virtual_destroyer.cpp
root@ubuntu:/lianxi/lianxi_c++/chapter11# ./a.out
=====START TEST=====
call Base constructor, this = 0x8ab7008
call Child constructor, this = 0x8ab7008
call GrandChild constructor, this = 0x8ab7008
&Laura = 0x8ab7008
=====SIZEOF TEST=====
sizeof(Laura) = 16
=====MEMORY STRCTURE TEST=====
p = 0x8ab7008
p+1 = 0x8ab700c, *(p+1) = 0
p+2 = 0x8ab7010, *(p+2) = 1
p+3 = 0x8ab7014, *(p+3) = 2
=====DELETE TEST=====
**********
call DeleteMemOnHeap Base version!
call GrandChild destroyer, this = 0x8ab7008
call Child destroyer, this = 0x8ab7008
call Base destroyer, this = 0x8ab7008
**********
=====END TEST=====
root@ubuntu:/lianxi/lianxi_c++/chapter11#
#include <iostream>
#include <stdio.h>
/*Base class*/
class Base
{
private:
int base_value;
public:
Base(int value = 0) : base_value(value)
{
std::cout << "call Base constructor, this = " << this << std::endl;
}
/*keyword virtual is not necessary*/
virtual ~Base(void)
{
std::cout << "call Base destroyer, this = " << this << std::endl;
}
};
/*Child class*/
class Child : public Base
{
private:
int child_value;
public:
Child(int value = 1) : child_value(value)
{
std::cout << "call Child constructor, this = " << this << std::endl;
}
/*keyword virtual is not necessary*/
virtual ~Child(void)
{
std::cout << "call Child destroyer, this = " << this << std::endl;
}
};
/*GrandChild class*/
class GrandChild : public Child
{
private:
int grandchild_value;
public:
GrandChild(int value = 2) : grandchild_value(value)
{
std::cout << "call GrandChild constructor, this = " << this << std::endl;
}
/*keyword virtual is not necessary*/
virtual ~GrandChild(void)
{
std::cout << "call GrandChild destroyer, this = " << this << std::endl;
}
};
void DeleteMemOnHeap(GrandChild* ptr)
{
std::cout << "**********" << std::endl;
std::cout << "call DeleteMemOnHeap GrandChild version!" << std::endl;
delete ptr;
std::cout << "**********" << std::endl;
return;
}
/*overload func*/
void DeleteMemOnHeap(Child * ptr)
{
std::cout << "**********" << std::endl;
std::cout << "call DeleteMemOnHeap Child version!" << std::endl;
delete ptr;
std::cout << "**********" << std::endl;
return;
}
/*overload func*/
void DeleteMemOnHeap(Base * ptr)
{
std::cout << "**********" << std::endl;
std::cout << "call DeleteMemOnHeap Base version!" << std::endl;
delete ptr;
std::cout << "**********" << std::endl;
return;
}
int main(void)
{
printf("=====START TEST=====\n");
GrandChild* ptr = new GrandChild;//named Laura
printf("&Laura = %p\n", ptr);
putchar(10);
printf("=====SIZEOF TEST=====\n");
printf("sizeof(Laura) = %d\n", sizeof(GrandChild));//16 on 32bit OS
putchar(10);
printf("=====MEMORY STRCTURE TEST=====\n");
int* p = (int*)(ptr);
printf("p = %p\n", p);
printf("p+1 = %p, *(p+1) = %d\n", p+1, *(p+1));
printf("p+2 = %p, *(p+2) = %d\n", p+2, *(p+2));
printf("p+3 = %p, *(p+3) = %d\n", p+3, *(p+3));
putchar(10);
printf("=====DELETE TEST=====\n");
#if 0
DeleteMemOnHeap(ptr);
#endif
#if 0
DeleteMemOnHeap((Child*)ptr);
#endif
#if 1
DeleteMemOnHeap((Base*)ptr);
#endif
printf("=====END TEST=====\n");
return (0);
}