C++虚函数表解析及作用

转载：http://blog.csdn.net/haoel/article/details/1948051/

转载的内容是具有很高的参考价值，但是这里，我们需要寻求另外的一些事情，就是虚函数表存在的意义。

其实，如果你在学习虚函数的时候感到迷茫，那是因为很多的书籍并没有解释虚函数的实现原理和意义，原因我想是因为如果展开来说这部分的内容可能会涉及的编译器实现的部分，所以这里，我也只是简单的阐述我的个人猜想，读者只能作为一种借鉴。

首先我要吹下牛B，C++真是一门好语言，初学的时候痛苦万分，学会了真的觉得自己鼠目寸光。

实例1代码如下：

#include <iostream>
using namespace std;

class A 
{
public:
    void Output() { cout << "A::Output()" << endl; }
};

int main(int argc, char ** argv) 
{
    A a;
    a.Output();
    return 0;
}
实例1输出

这是一个很基本的C++程序，我假设读者能够明白这个简单程序。
我们现在对这个程序做一个很小的改动

实例2代码如下：

#include <iostream>
using namespace std;

class A 
{
public:
    void Output() { cout << "A::Output()" << endl; }
};

int main(int argc, char ** argv) 
{
    A a;
    a.A::Output();
    return 0;
}
实例2输出

我们发现，我们在main函数中仅仅是使用了一个‘A::’，但是输出结果和实例1是相同的。这个说明一个问题，实例1的写法是实例2的写法的一个简单写法，或者这么说，实例1的写法默认了含有‘A::’，也就是说实例1含有一种默认行为。

有了上面的一个基本假设，我们现在来看看当子类和父类含有相同的函数名的时候会是一种什么现象。

实例3代码如下：

#include <iostream>
using namespace std;

class A 
{
public:
    void Output() { cout << "A::Output()" << endl; }
};

class B : public A
{
public:
    void Output() { cout << "B::Output()" << endl; }
};

int main(int argc, char ** argv) 
{
    B b;

    b.Output();              // 1
    b.B::Output();           // 2
    b.A::Output();           // 3
    b.B::A::Output();        // 4

    return 0;
}
实例3输出

我们看到1和2的输出是一致的，3和4的输出是一致的，我们可以推测，1是2的简写形式，3是4的一种简写形式（其实3不是4的一种简化形式，目前而言我只能猜测）。
我们可以从4的形式上发现，B是继承自A的，否则不可能会有这种形式的存在。
我们还可以从2的形式上发现，函数Output一定是一个成员函数，否则不会有此种形式的存在。
C++语言为了简化我们的行为，做了很多后台的行为，用来简化形式，这是我觉得C++语言伟大的地方，但是它隐藏的东西又没有人告诉你，所以初学的时候只能依葫芦画瓢，不知道怎么回事，看到一些C++代码总感到疑惑，觉得这种范式我并没有见过。

实例4代码如下：

#include <iostream>
using namespace std;

class A 
{
public:
    virtual void Output() { cout << "A::Output()" << endl; }
};

class B : public A
{
public:
    void Output() { cout << "B::Output()" << endl; }
};

int main(int argc, char ** argv) 
{
    B b;
    A * a = &b;

    (*a).Output();              // 1
    // (*a).B::Output();        // 2
    (*a).A::Output();           // 3
    (*a).B::A::Output();        // 4

    return 0;
}
实例4输出

我们发现2是没有通过编译的，原因我猜测是因为Output是成员函数，而成员函数的第一个形参是一个this指针，this指针的类型是B *，a的类型是A *，但是 A *是无法自动转换成B *的，所以语句2是无法通过编译的。
不过3和4的输出是一致的。现在我们来查看一下3和4的函数指针的值

实例5代码如下：

#include <iostream>
#include <stdio.h>
using namespace std;

class A 
{
public:
    virtual void Output() { cout << "A::Output()" << endl; }
};

class B : public A
{
public:
    void Output() { cout << "B::Output()" << endl; }
};

int main(int argc, char ** argv) 
{
    B b;
    A * a = &b;

    (*a).Output();              // 1
    // (*a).B::Output();        // 2
    (*a).A::Output();           // 3
    (*a).B::A::Output();        // 4

    printf("%p\n", &(A::Output));
    printf("%p\n", &(B::A::Output));

    return 0;
}
输出5实例

我们发现他们的指针值是相同的。我们可以明白同一个函数的如果地址只有一个副本，但是他的访问方式可以有多种形式。

实例6代码如下：

#include <iostream>
#include <stdio.h>
using namespace std;

class A 
{
public:
    virtual void Output() { cout << "A::Output()" << endl; }
};

class B : public A
{
public:
    void Output() { cout << "B::Output()" << endl; }
};

class C : public A
{

};

int main(int argc, char ** argv) 
{
    B b;
    A * a = &b;

    (*a).Output();              // 1
    // (*a).B::Output();        // 2
    (*a).A::Output();           // 3
    (*a).B::A::Output();        // 4
    (*a).C::A::Output();        // 5

    return 0;
}
实例6输出

从4和5的输出是一致的情况下，我们可以推断函数4和5的函数地址是一致的。

以上所有的代码仅仅是针对成员函数的情况，对于成员变量的情况后文继续阐述。
我们可以总结，虚函数的出现，仅仅是为了实现语句2，而虚函数是通过虚函数表实现的，也就是说，虚函数表是多态机制的根本。
我们可以看出基类对象是无法访问子类对象的特有的成员函数！！！这是语句2编译不通过的主要原因。基类不包含子类，但是子类是包含基类的。

下面让我们来看看类的成员变量。

实例7代码如下

#include <iostream>
#include <stdio.h>
using namespace std;

class A 
{
public:
    A() : m_mem(0) {}
    A(int x) : m_mem(x)  {}

    int m_mem;
};

class B : public A
{
public:
    B() : A(1) {}
};

class C : public A
{
public:
    C() : A(2) {}
};

class D : public B, public C
{
};

int main(int argc, char ** argv) 
{
    D b;
    
    // cout << b.m_mem << endl;     // 1
    cout << b.A::m_mem << endl;     // 2
    cout << b.B::m_mem << endl;     // 3
    cout << b.B::A::m_mem << endl;  // 4
    cout << b.C::m_mem << endl;     // 5
    cout << b.C::A::m_mem << endl;  // 6

    return 0;
}
实例7输出

1是无法通过编译的，因为存在二义性，2,3,4的结果是一致的，5,6的结果是一致的，从这个例子，我们知道，如果出现多次继承同一个基类的时候，我们会产生多个成员变量的副本，这个在实现上我们可以通过域名访问去除二义性，但是在实际的使用的时候，我们可能会觉得这是一个冗余的副本，我们并不希望存在这种情况，所以我们会有虚继承的方式来去达到我们的目的

实例8代码如下：

#include <iostream>
#include <stdio.h>
using namespace std;

class A 
{
public:
    A() : m_mem(0) {}
    A(int x) : m_mem(x)  {}

    int m_mem;
};

class B : virtual public A
{
public:
    B() : A(1) {}
};

class C : virtual public A
{
public:
    C() : A(2) {}
};

class D : public B, public C
{
};

int main(int argc, char ** argv) 
{
    D b;
    
    cout << b.m_mem << endl;        // 1
    cout << b.A::m_mem << endl;     // 2
    cout << b.B::m_mem << endl;     // 3
    cout << b.B::A::m_mem << endl;  // 4
    cout << b.C::m_mem << endl;     // 5
    cout << b.C::A::m_mem << endl;  // 6

    return 0;
}
实例8输出

我们发现1是可以通过编译的了，而且所有的输出都是0，说明此时的类A的构造函数是直接通过D发起的，并不是间接的通过B或者C发起的。相反，实例7上面的结果说明类A的构造函数一共执行了两次，一次是通过B发起的，一次是通过C发起的。另外实例8说明了一个问题，如果类A已经执行过构造函数，B或者C不在调用类A的构造函数了。

这两个例子都有点绕，主要的原因是多重继承对于基类的构造函数的调用顺序，在有虚继承和没有虚继承的情况下是不同的。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • 《C++ Primer》读书笔记
    前言 把《C++ Primer》[https://book.douban.com/subject/25708312...
    尤汐Yogy阅读 13,149评论 1赞 51
  • Java初级面试题
    1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语...
    子非鱼_t_阅读 31,981评论 18赞 399
  • 常见C++面试题及基本知识点总结（一）
    1. 结构体和共同体的区别。 定义： 结构体struct：把不同类型的数据组合成一个整体，自定义类型。共同体uni...
    breakfy阅读 6,450评论 0赞 22
  • C++必懂的基本概念
    1.面向对象的程序设计思想是什么？ 答：把数据结构和对数据结构进行操作的方法封装形成一个个的对象。 2.什么是类？...
    少帅yangjie阅读 10,440评论 0赞 14
  • C++ 教程 | 菜鸟教程
    重新系统学习下C++；但是还是少了好多知识点；socket；unix；stl；boost等； C++ 教程 | 菜...
    kakukeme阅读 20,230评论 0赞 50