C++虚函数/纯虚函数/虚析构函数的个人理解

离过年还有一周半，加紧完成自己的计划，自律==自由！

学习到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);
}