最近再读一遍C++Primer Plus，在虚函数描述（中文版P501）中有以下描述：
        如果数组成员指向的是Brass对象，则调用Brass::ViewAcct()；如果指向的的是BrassPlus对象，则调用BrasPlus::ViewAcct()。如果Brass::ViewAcct()被声明为虚的，则在任何情况下都将调用Brass::ViewAcct()。
       个人觉得这句话描述为有应该是：
        如果Brass::ViewAcct()未被声明为虚的，则在任何情况下都将调用Brass::ViewAcct()。
       特地翻阅了英文原版的描述，发现和译本意思相同，可能是原版就有这个问题，而译者翻译这段时并未仔细考虑，网上搜索了一下，发现也有网友提出此类疑问，特写此帖说明。
        英文描述：
        If the array member points to a Brassobject,Brass::ViewAcct() is invoked;if the array member points to a BrassPlusobject,BrassPlus::ViewAcct() is invoked. If Brass::ViewAcct() were been declared as virtual, Brass:ViewAcct() would be invoked in
 all cases.

在看公司代码时， 发现了一处关于虚函数的我比较难以理解的地方，大致描述如下：


  
子类继承父类， 包括继承了虚函数和非虚函数
  
子类调用父类中的非虚函数 Base::PrintWord(), 在这个非虚函数里它又调用了虚函数doPrintWord()。
  
实验表明调用的虚函数执行的是重写的子类虚函数。
  

大致的代码可以简写为以下一个例子：

#include <iostream>

using namespace std;

class Base{

public:
    void PrintWord(const char* c)
    {
        printf("called in Base::PrintWord, and  pointer of this is : 0x%x\n",this);
        doPrintWord(c);
    }
    virtual void doPrintWord(const char* c)
    {
        printf("%s",c);
        printf("Base here\n");

        printf("Base : 虚函数的this指针地址：0x%x \n\n",this);

    }
};


class Derived: public Base
{
public:
    void testprint(const char* c)
    {
        Base::PrintWord(c);
    }
private:
    void doPrintWord(const char* c)
    {
        printf("%s",c);
        printf("Derived here\n");

        printf("子类虚函数doPrintWord的this指针地址：0x%x \n\n",this);
    }
};

int main(int argc, char *argv[])
{
    Derived ss;

    ss.testprint("");


    printf("Derived : 0x%x\n",&ss);

    return 0;
}

为了解决这一疑问，有必要理清虚函数和非虚函数的区别：


  
虚函数： 虚函数其实是一种动态绑定机制，因为在编译时，编译器是不知道是该调用父类中的虚函数还是子类中的虚函数的，而是在程序执行过程中，动态确定的。虚函数的本质是，C++编译器透过某个表格，在执行时期「间接」调用实际上欲绑定的函数（注意「间接」这个字眼）。这样的表格称为虚拟函数表（常被称为vtable）。每一个「内含虚拟函数的类」，编译器都会为它做出一个虚拟函数表，表中的每一笔元素都指向一个虚拟函数的地址。此外，编译器当然也会为类别加上一项成员变量，是一个指向该虚拟函数表的指针（常被称为vptr）。 

  每一个由此类衍生出来的对象，都有这么一个vptr。当我们透过这个对象调用虚拟函数，事实上是透过vptr 找到虚拟函数表，再找出虚拟函数的真正地址。


如何理解上面的间接调用呢？下文会详细说以下如何间接调用虚函数的。


  
非虚函数： 非虚函数在编译器就已经静态确定，地址也是静态确定的， 一个子类 如果继承他的父类非虚函数，那么他们其实共享一个非虚函数地址。 

  假如存在一个非虚函数NonVirtualFunc(), 那么Base::NonVirtualFunc()和Derived::NonVirtualFunc() 具有一个相同的函数地址， 这里的函数地址可以利用调试器在调试阶段可以看出来， 是相同的。


子类在调用这些非虚函数和虚函数，都经历了怎样的过程？


  
一个子类的成员函数在被调用时，都会默认传入一个参数this. 这个this 关键字 区别与函数地址， 他代表的是实例地址，一个类中的非静态变量、虚函数表都是通过this关键字进行寻址的。 
  
  
非虚函数的地址对编译期来说“静态”的，也就是函数地址在编译期就已经确定了，实例地址对于非虚函数只是那个 this 指针参数。
  
  
虚函数的地址，是先到实例的地址this前面去查找它的虚函数表所在的地址。然后从虚函数表里取出该函数所对应的元素（虚函数表是一个函数指针数组）来call的。（当然一个已知的类的虚函数表的内容 也是编译期静态的，但不同类的虚函数表内容不同，即运行时多态的基础）


this 指针

Q1：什么情况下可以使用this指针？


  
this只能在成员函数中使用。全局函数，静态函数都不能使用this。实际上，成员函数默认第一个参数为T* const register this。
  
  
为什么this指针不能在静态函数中使用?
  
  
大家可以这样理解，静态函数如同静态变量一样，他不属于具体的哪一个对象，静态函数表示了整个类范围意义上的信息，而this指针却实实在在的对应一个对象，所以this指针当然不能被静态函数使用了。 

  静态函数只能调用静态函数和使用静态变量，但是this指针所指向的变量是非静态的，所以静态函数中使用this指针不合理也不合法。


Q2: 

问题解释



void testprint(const char* c)
{
    Base::PrintWord(c);
}



对于上述的函数调用来实现多态，我们就尝试用以上的知识来解释一下：


  
对于非虚函数PrintWord()， 子类在继承时保持了该函数的函数地址不变， 子类在调用Base::PrintWord()时， 相当于调用了Derived::PrintWord()。
  
由于一个类的非静态成员函数在调用非静态成员函数时，会将this指针作为参数默认的传入到函数中， 那么该调用过程就类似于Derived::PrintWord(this, c); 
  
所以在Base::PrintWord(this, c) 中调用虚函数doPrintWord()，其在虚函数表中寻址是基于当前this指针进行寻址的，而this指针当前指向的是子类对象，那么最终执行的虚函数是子类重载的虚函数doPrintWord()，最终实现了多态。 
  

写到这，我觉得公司原有的代码虽然没有问题，实现了多态，但是这样的写法确实让人感到迷惑，不如直接调用子类继承的非虚函数来的直接。 

在很多次面试中，我发现面试官都喜欢问同一个问题：谈谈你对多态的认识。 

遇到这个问题，通常我第一句话就是：多态分为静态多态和动态多态，然后静态多态就是balabala动态多态是巴拉巴拉。关于静态多态这里不再赘述。这里先描述一下博主在CVTE面试时遇到的多态问题。面试官要求：你先写一个多态的例子，然后我就飞快的写下了下面的语句：



class Animal
{
public:
    virtual void eat()
    {
        cout << "Animal eat" << endl;
    }
};

class Dog : public Animal
{
private:
    void eat()
    {
        cout << "dog eat" << endl;
    }
};

int main()
{
    Animal *A = new Dog;
    A->eat();

    return 0;
}

然后面试官接着问，这个类Dog中的函数eat为什么要把属性设置为public，设置为private行不行呢，如果设置为private，基类指针是否还可以访问这里的eat函数？当时遇到这个问题有点懵，因为接口函数都是用来被类的对象调用的，一般就直接设置为public了，怎么会想到设为私有呢。后来自己回来想清楚了，面试官这样问其实就是考察你对虚函数原理是否了解。 

先公布一下答案：答案是可以的。下面说说原因。

类的内存结构 

如果一个类中有虚函数，类的起始位置将存放虚函数表的地址（4个字节），虚函数表是按顺序存放该类的虚函数。虚函数表地址之后再存放该类的数据成员。在无继承的情况下，不管虚函数有多少个，系统为其分配的内存空间只有4个字节。这样，我们就知道用sizeof关键字计算类的大小。

虚函数表 


多态与成员函数的访问权限是没有关系的, 即是两回事。 

现在来解释一下为什么可以突破对象访问私有函数的限制：编译器编译是静态的，运行时多态是动态的，也就是说编译器在编译的时候不太关注动态特性。A的指向Animal类型对象的指针，编译器编译时将A当成指向Animal类型对象处理，Animal中恰好有个成员函数是eat()，并且Animal中的eat()函数属性是public，所以A->eat()语句是合法的，编译时可以通过编译器的检查，但程序在执行时通过虚函数表动态匹配调用的虚函数，所以我们看到的执行结果是“dog eat”

基类定义了虚函数, 并且是public的，那么子类只要override 虚函数 无论放在什么样的访问权限下(private,protect,public), 都以基类的访问权限为准, 即是public的。

关于虚函数的特点： 

（1）要有子类公有继承父类，虚函数才有意义 

（2）子类重写的父类的虚函数也是虚函数（类Dog中的eat函数是虚函数），只不过省略了关键字virtual 

（3）虚函数必须是所在类的成员函数，而不能是友元函数或静态函数。因为虚函数调用要靠特定的对象来决定激活哪一个函数。 

（4）构造函数不能是虚函数，原因是构造函数在创建时首先被调用，也就是说在编译时就要把构造函数的地址绑定好。而析构函数可以是虚函数，因为析构函数最后调用，可以在运行时动态匹配。

虚析构 
把析构函数设为虚函数主要是为了防止内存泄漏 

我们首先要知道的事实（单继承时）： 

构造函数的调用顺序：从当前类往上找父类，一直找到最上层的父类，我们可以理解为始祖，它是最先构造的，然后沿着继承路径依次往下构造，一直到当前类。 

析构函数的调用顺序：从当前类开始析构，析构完再沿着继承路径往上找父类 ，析构父类 ，再找到最上层的父类  析构。

分析以下代码：



#include <iostream>
using namespace std;

class A
{
public:
    A()
    {
        cout << "A的构造函数" << endl;
    }
    ~A()
    {
        cout << "A的析构函数" << endl;
    }
};

class B:public A
{
public:
    B()
    {
        p = new char[20];
        cout << "B的构造函数" << endl;
    }
    ~B()
    {
        if (p != NULL)
            delete[] p;
        cout << "B的析构函数" << endl;
    }

private:
    char *p;
};

void func(A *pa)
{
    delete pa;
}


int main()
{
    A *pa = new B;      //构造函数被调用两次，A先B后
    func(pa);           //析构函数只被调用一次，A调用

    return 0;
}


执行结果： 


在main函数中用new建立一个子类无名对象和定义一个父类对象指针，并将匿名对象的地址赋给父类对象指针，当我们用delete运算符回收匿名对象时，系统只执行父类的析构函数，而不执行子类的析构函数。 

解决办法：把基类的析构函数定义为虚函数

关于这类问题，博主心血来潮，还想赘述一番，于是又举了个栗子： 

（1）不是虚析构

#include <iostream>
using namespace std;

class A
{
public:
    ~A()                                //(1)基类A的析构未加virtual，即不是虚析构
    {
        cout << "A的析构" << endl;
    }
};

class B : public A
{
public:
    ~B()
    {
        cout << "B的析构" << endl;
    }
};

int main()
{
    A *pa1 = new A;
    delete pa1;     //A的析构

    A *pa2 = new B;
    delete pa2;     //A的析构

    B *pb = new B;
    delete pb;      //B的析构  A的析构

    return 0;
}

（2）是虚析构



#include <iostream>
using namespace std;

class A
{
public:
    virtual ~A()                                //(2)基类A的析构加virtual，即是虚析构
    {
        cout << "A的析构" << endl;
    }
};

class B : public A
{
public:
    ~B()
    {
        cout << "B的析构" << endl;
    }
};

int main()
{
    A *pa1 = new A;
    delete pa1;     //A的析构

    A *pa2 = new B;
    delete pa2;     //B的析构  A的析构

    B *pb = new B;
    delete pb;      //B的析构  A的析构

    return 0;
}

还有一个可能会被误导的地方：虚函数的默认参数是动态还是静态 

看下面的栗子：

#include <iostream>
using namespace std;

class A
{
public:
    virtual void fun(int i = 10)
    {
        cout << "A::fun() is calling, i = " << i << endl;
    }
};

class B:public A
{
public:
    virtual void fun(int i = 99)
    {
        cout << "B::fun() is calling, i = " << i << endl;
    }
};

int main()
{
    A *pa = new B;
    pa->fun(); 

    return 0;
}




相信很多朋友觉得结果为“B::fun() is calling, i = 99”更符合预期。其实这是C++的虚函数规则，虚函数是动态绑定的，而虚函数的默认参数是静态绑定的，因此在编译时已经把i的值确定为10，而不管在后面执行时动态调用哪个虚函数。

多重继承 

一个类有多个直接基类的继承关系称为多继承 



class D : public B, public A, public C
{
};

多继承时的构造函数调用顺序：按照它们被继承时声明的顺序（从左到右）（B A C）

钻石型继承二义性：  

如果一个派生类从多个基类派生，而这些基类又有一个共同的基类，则在对该基类中声明的名字进行访问时，可能产生二义性。

虚继承 和 虚基类 
虚继承主要用来解决多继承时可能发生对同一父类继承多次而产生的二义性问题。为最远的子类提供唯一的父类成员，而不重复产生多次复制。多个子类继承自同一个父类时，将继承方式指定为虚继承（继承时加关键字virtual）即可，此时的父类称为虚基类。



class A{};
class B : virtual public A{};
class C : virtual public A{};
class D : public C, public B
{
};

这里的A就是虚基类。

问题描述:
下面的代码试图去通过运行时程序分析和验证C++的虚表实现机制。
下面的代码在探究多重继承情况下，虚表的情况


copy代码, g++编译，观察输出结果，会发现，在派生类@Derived 中重新定义了虚函数 virtual void f(void)
这样以来，基类的函数实现就会被覆盖。通过虚表调用函数f，都会调用重新定义的这个，而不是旧的(实质是指针的覆盖)。


但是在我测试的时候出现了一个很奇葩的问题
观察输出，你会看到这里Derived::f()的函数实现的地址，居然有三个不同的地址，我都惊呆了。。。
理论上，实例化一个Derived::f()函数就可以了。把这个实例化的函数首地址指针覆盖到对应的虚表中即可。
但是这里居然出现了三个不同的Derived::f() （最起码看起来是不一样的。他们的地址不同额。。。）
表示很困惑。。。












为什么居然会有三个不同的Derived::f()，故意的嘛？



/*******************************************************************
Programmer  :   EOF
Date        :   2015.06.13
File        :   virtual_function_for_multiple_inheritance.cpp
E-mail      :   jasonleaster@gmail.com

 ******************************************************************/

#include <iostream>

using namespace std;

typedef  void (*FUN) (void);

class Base_1
{
    public:

        int num;

        Base_1():prv_data(100), num(100) { }

        virtual void f(void){ cout << " Base_1::f()" << endl; }
        virtual void g(void){ cout << " Base_1::g()" << endl; }
        virtual void h(void){ cout << " Base_1::h()" << endl; }

    private:
        /*
           Private  Data
         */
        int prv_data;

};

class Base_2
{
    public:

        int num;

        Base_2():prv_data(200), num(200) { }

        virtual void f(void){ cout << " Base_2::f()" << endl; }
        virtual void x(void){ cout << " Base_2::x()" << endl; }

    private:
        /*
           Private  Data
         */
        int prv_data;

};

class Base_3
{
    public:

        int num;

        Base_3():prv_data(300), num(300) { }

        virtual void g(void){ cout << " Base_3::g()" << endl; }

    private:
        /*
           Private  Data
         */
        int prv_data;

};

class Derived : public Base_3, public Base_2, public Base_1
{
    public:

        int num;

        Derived():num(42), prv_data(42) { }

        virtual void y(void){ cout << " Derived::y()" << endl; }

        /*
           Here we re-implement the virtual function @f().
           Compiler will rewrite the virtual table
         */
        virtual void f(void){ cout << " Derived::f()" << endl; }
        virtual void g(void){ cout << " Derived::g()" << endl; }


    private:
        int prv_data;
};

template<class T>
unsigned long* get_element(T &obj, int offset = 0, int vprt_offset = 0)
{
    return ((unsigned long*)*((unsigned long*)(&obj) + vprt_offset)) + offset ;
}

int main()
{
    Derived d;

    cout << "Virtual Table of @Base_3 and @Derived:" << endl;

    cout << (int*)*get_element(d, 0, 0) << endl;
    ((FUN)(*get_element(d, 0, 0))) ();

    cout << (int*)*get_element(d, 1, 0) << endl;
    ((FUN)(*get_element(d, 1, 0))) ();

    cout << (int*)*get_element(d, 2, 0) << endl;
    ((FUN)(*get_element(d, 2, 0))) ();


    cout << "Virtual Table of @Base_2:" << endl;

    cout << (int*)*get_element(d, 0, sizeof(Base_3)/8) << endl;
    ((FUN)(*get_element(d, 0, sizeof(Base_3)/8))) ();

    cout << (int*)*get_element(d, 1, sizeof(Base_3)/8) << endl;
    ((FUN)(*get_element(d, 1, sizeof(Base_3)/8))) ();


    cout << "Virtual Table of @Base_1:" << endl;
    cout << (int*)*get_element(d, 0, (sizeof(Base_3) + sizeof(Base_2))/8) << endl;
    ((FUN)(*get_element(d, 0, (sizeof(Base_3) + sizeof(Base_2))/8))) ();
  
    cout << (int*)*get_element(d, 1, (sizeof(Base_3) + sizeof(Base_2))/8) << endl;
    ((FUN)(*get_element(d, 1, (sizeof(Base_3) + sizeof(Base_2))/8))) ();

    cout << (int*)*get_element(d, 2, (sizeof(Base_3) + sizeof(Base_2))/8) << endl;
    ((FUN)(*get_element(d, 2, (sizeof(Base_3) + sizeof(Base_2))/8))) ();

    return 0;
}