虚函数

面试的时候,常常宣称自己是一个C++程序员,不免就会被问一些有关C++的问题,例如虚函数的实现原理;析构函数是否能定义为虚函数等等。很多时候都回答不上来,就总会以时间久了忘了,搪塞过去,面试完,可能回去查查答案,但也总是不求甚解。

既然有了博客,我就准备看看这些方面的内容,希望能记录下来,有所积累。于是就到网上查,或在书上找找,后来发现里面的内容太多了,不是一篇两篇博客就能写完的。于是没有办法,就只有硬着头皮写一个系列了。今天是第一部分虚函数和虚继承。

C++的关键字virtual只能用在两个地方,一是定义类的成员函数为虚函数,二是定义类的继承关系为虚继承。这两点的用处大相径庭,但是在设计思想上还是有一定的共同性的。这篇文章先讲虚函数,下一篇讲虚继承。

虚函数

虚,不实也。也可以理解为看到的和实际的不一样。虚函数存在的目的只有一个,那就是实现多态。关于多态,可以去参考各种教科书,上面都有详细的说明。虚函数在实现多态时,通过一种间接的运行时(而不是编译时)的机制激活(调用)的函数。下面看一个多态的简单例子。

多态的简单例子view raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/*
* polymorphism.cc: example of polymorphism
*/


#include <iostream>

using namespace std;

class base {
public:
virtual void f(){ cout << "in base:f" << endl;}
};

class derived1: public base {
public:
virtual void f(){ cout << "in derived1:f" << endl;}
};

class derived2: public base {
public:
virtual void f(){ cout << "in derived2:f" << endl;}
};

void call_func(base* pb) {
pb->f();
}

int main(void) {
base* pb = new base();
base* pd1 = new derived1();
base* pd2 = new derived2();
call_func(pb);
call_func(pd1);
call_func(pd2);
}

运行结果如下1:

从运行结果来看,函数call_func()最后实际调用的f()要到运行时,根据传入的参数,才能确定调用的是哪个函数。

那么虚函数的这种性质是如何实现的呢?答案是虚表(vtable)。具体的做法是,在对象的存储空间里面开辟一个指针,指针指向一个存放着虚函数地址的函数指针表。编译器在生成调用虚函数的指令时,按照偏移量,从虚表中取相应的函数指针进行调用。子类的虚函数会覆盖父类中对应虚函数在虚表中的位置,所以在调用的时候,就调用到了子类的函数了。也许这段话没有说太清楚,下面看一段代码或许会有帮助。

测试虚表的例子view raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/*
* test virtual functions
*/


#include <iostream>

using namespace std;

class base {
public:
virtual void f(){ cout << "in base:f" << endl;}
};

class derived: public base {
public:
virtual void f(){ cout << "in derived:f" << endl;}
};

typedef void(*fun)(void);
#define VTAB(pclass) ((long*)(*(long*)(pclass)))

int main(void) {
base* pb = new base();
pb->f();
base* pd = (base*) new derived();
pd->f();

cout << "--- call through vtable ---" << endl;
fun pfun = (fun)*VTAB(pd);
pfun();
pfun = (fun)*VTAB(pb);
pfun();
derived* pd_fake = (derived*)pb;
pfun = (fun)*VTAB(pd_fake);
pfun();

pfun = (fun)*VTAB(pd);
cout << "value of *pfun is: " << *pfun << endl;
pfun = (fun)*(VTAB(pd) + 1);
cout << "value of *pfun is: " << *pfun << endl;
}

输出结果如下:

上面这段代码的第20行,通过定义指针的方式2,直接访问虚表,发现它的输出与通过对象调用是一直的,而且指针的类型无关。由上面的代码也可以看出虚表在对象的内存空间中是怎么分布的。对象的起始地址,就是虚表指针。虚表的最后一项为0,代表虚表结束。上面程序的最后一项输出可以看出来。

用一张图来说明情况。

在多个虚函数的情况下,子类仅仅覆盖在子类重载的虚函数,而子类新定义的虚函数,加入到虚表的最后。下面这个例子就是多个虚函数的情况。

多个虚函数view raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// test virtual functions

#include <iostream>

using namespace std;

class base {
public:
virtual void f(){ cout << "in base:f" << endl;}
virtual void f0(){ cout << "in base:f0" << endl;}
};
class derived: public base {
public:
virtual void f(){ cout << "in derived:f" << endl;}
virtual void f1(){ cout << "in derived:f1" << endl;}
};

typedef void(*fun)(void);

#define VTAB(pclass) ((long*)(*(long*)(pclass)))

int main(void) {
base* pb_real = new base();
pb_real->f();
base* pb = (base*) new derived();
pb->f();
pb->f0();

cout << "--- call function through vtable ---" << endl;
fun pfun = (fun)*VTAB(pb);
pfun();
pfun = (fun)*(VTAB(pb)+1);
pfun();
pfun = (fun)*(VTAB(pb)+2);
pfun();
}

输出结果:

虚表的组织结构如下:

由图中可以看出,子类的f()覆盖了基类的f(),而基类的f0()依然存在,子类的f1()添加到了虚表的最后。

当有多个基类时,子类会为每个基类添加一个虚表指针,指针的顺序按照类定义时的声明顺序。下面这个例子就是这样的。

虚函数多重继承view raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
// test virtual functions

#include <iostream>

using namespace std;

class father_b1 {
public:
virtual void f(){ cout << "in father of base1:f" << endl;}
virtual void fbf(){ cout << "in father of base1:fbf" << endl;}
};

class father1_b1 {
public:
virtual void f(){ cout << "in father1 of base1:f" << endl;}
virtual void f1bf(){ cout << "in father1 of base1:f1bf" << endl;}
};

class base {
public:
virtual void f(){ cout << "in base:f" << endl;}
virtual void bf0(){ cout << "in base:f0" << endl;}
};

class base1: public father_b1, public father1_b1{
public:
virtual void f(){ cout << "in base1:f" << endl;}
virtual void b1f0(){ cout << "in base1:f0" << endl;}
};

class derived: public base1, public base {
public:
virtual void f(){ cout << "in derived:f" << endl;}
virtual void f1(){ cout << "in derived:f1" << endl;}
};

typedef void(*fun)(void);

#define VTAB(pclass) ((long*)(*(long*)(pclass)))
#define VTAB1(pclass) ((long*)(*(((long*)(pclass)) + 1)))
#define VTAB2(pclass) ((long*)(*(((long*)(pclass)) + 2)))


int main(void) {
derived* pd = new derived();

cout << "--- vtable ---" << endl;
fun pfun = (fun)*VTAB(pd);
pfun();
pfun = (fun)*(VTAB(pd)+1);
pfun();
pfun = (fun)*(VTAB(pd)+2);
pfun();
pfun = (fun)*(VTAB(pd)+3);
pfun();

cout << endl;
cout << "--- vtable + 1 ---" << endl;
pfun = (fun)*VTAB1(pd);
pfun();
pfun = (fun)*(VTAB1(pd)+1);
pfun();

cout << endl;
cout << "--- vtable + 2 ---" << endl;
pfun = (fun)*VTAB2(pd);
pfun();
pfun = (fun)*(VTAB2(pd)+1);
pfun();
}

输出结果:

这是一个比较复杂的继承关系了,可以看出最后的derived类里面已经有3个虚表指针了,也就是说,子类会讲所有的父类的虚表继承下来,并将自己的虚函数添加到第一个虚表的最后。还有一点,就是子类的虚函数会覆盖所有基类的对应虚函数,图中的derived::f()就覆盖了3处。其组织结构如下:

构造函数和析构函数的调用顺序

这个问题本来和虚函数没有关系,但是为了后面解释关于构造函数为什么不能声明为virtual,添加到这里的。

构造函数的调用顺序是,先调用父类的构造函数,然后调用成员变量的构造函数,最后调用子类自身的构造函数,多个父类时,按照父类的继承时的声明顺序调用,成员变量的构造函数也按照声明顺序调用。

析构函数的调用顺序与构造函数的正好相反,先调用子类自身的析构函数,然后是成员变量的析构函数,最后是父类的构造函数,多个父类时,按照父类的继承时的声明的相反顺序调用,成员变量的构造函数也按照声明的相反顺序调用。

下面是一段测试调用顺序的代码

构造和析构函数的调用顺序view raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/*
* 研究构造函数的调用顺序
* 1. 首先调用基类的构造函数(如果有基类);如果有多个基类,则按基类被列出的顺序调用;
* 2. 调用这个类的成员对象的构造函数(如果有的话);如果有多个成员对象,则按成员对象定义的顺序被调用(与参数列表中列出的顺序无关);
* 3. 最后调用这个类自身的构造函数;
* 4. 析构函数正好相反;
* 注意:如果有虚基类,则先调用虚基类的构造函数。在调用基类的构造函数,如果有多个虚基类,则按列出的顺序调用;
*/


#include <iostream>

using namespace std;

class father_base_a{
public:
father_base_a(){cout<<"This is father_base_a;"<<endl;}
virtual ~father_base_a() { cout << "This is ~father_base_a" << endl; }
};

class base_a: public father_base_a{
public:
base_a(){cout<<"This is base_a;"<<endl;}
virtual ~base_a() { cout << "This is ~base_a" << endl; }
};

class base_b{
public:
base_b(){cout<<"This is base_b;"<<endl;}
virtual ~base_b() { cout << "This is ~base_b" << endl; }
};

class member_a{
public:
member_a(){cout<<"This is meber_a;"<<endl;}
virtual ~member_a(){cout<<"This is ~meber_a;"<<endl;}
};

class member_b{
public:
member_b(){cout<<"This is member_b;"<<endl;}
virtual ~member_b(){cout<<"This is ~meber_b;"<<endl;}
};

class derived : public base_b, public base_a
{
public:
member_a ma;
derived(){
cout<<"This is derived;"<<endl;
}
virtual ~derived() { cout << "this is ~derived()" << endl; }

private:
member_b mb;
};

int main(void)
{

derived de;
cout << "---------" << endl;
}

输出结果

从输出结果可以看出,先调用了base_b的构造函数,然后调用base_a的构造函数(但得先调用base_a的父类father_base_a),然后是成员member_amember_b的构造函数,最后是derived自己的构造函数。析构的过程正好相反。

构造函数不能声明为虚函数

这也是面试中常被问道的一个问题。原因应该有两个

  1. 在构造函数之前,类的对象是不存在的,那么也没有vtable,也无法通过vtable找到虚函数。所有无法定义为虚函数。
  2. 构造函数是先调用父类,最后才是子类的构造,因为子类的内存布局是基于父类。如果使用虚构函数,那么在调用父类的构造函数时,实际调用的是子类的构造函数,那么就无法完成对象的构造。
  3. 虚函数的主要目的是多态,运行时确定调用那个函数,对象的构造过程是确定的,使用虚函数没有意义。

实际上,如果将构造函数声明为虚函数,编译时,gcc会报错。

析构函数声明为虚函数

在基类的声明中一般都应该将析构函数声明为虚函数。首先由于析构函数没有构造函数的问题,所以是可以声明为虚函数的。其次,可能程序需要利用析构函数为虚函数的特性,才能讲资源释放完全。

首先来看一个代码例子

析构函数为虚函数view raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// 分析析构函数为虚函数时的特性

#include <iostream>

using namespace std;

class base{
public:
virtual ~base(){ cout << "in base::~base()" << endl; }
};

class derived: public base{
public:
virtual ~derived(){ cout << "in derived::~derived" << endl; }
};

class base1 {
public:
~base1(){ cout << "in base1::~base1()" << endl; }
};

class derived1: public base1{
public:
~derived1(){ cout << "in derived1::~derived1" << endl; }
};

int main(void){
base *pbase = new derived();
delete pbase;
cout << "--------" << endl;
base1 *pbase1 = new derived1();
delete pbase1;
}

运行结果

由结果可以看出,由于base1的析构函数没有声明为虚函数,在delete pbase1时,没有调用derived1的析构函数,那么在derived1中申请的资源就无法释放。而因为base类中的修改函数声明为了虚函数,就没有这样的问题。

什么时候使用虚函数

包含了虚函数的成员函数的对象,由于需要存放虚表地址,那么就比不包含虚函数的对象,多出了一块空间,32位为4个字节,64位为8个字节。如果没有用到多态,而且有大量的对象存在时,需要考虑这个开销。

在需要使用多态,或在定义接口时,需要使用虚函数。特别是定义接口时,最好使用纯虚函数。

另外,将私有成员函数声明为虚函数,可以通过对象的虚表指针的方式访问,造成了封装的不严密。例如,通过在前面的例子中定义的VTAB宏,就可以直接获取函数指针,然后调用函数,这种调用是需要检查这个成员函数的性质的。

同名函数隐藏规则

在父类和子类中如果存在同名的函数,那么一定要小心了,这时需要重载父类中所有同名的函数。首先来看一个关于同名函数的例子

诡异的同名函数view raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/*
* 测试c++隐藏规则:
* (1)如果派生类的函数与基类的函数同名,但是参数不同。
* 不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)。
* (2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数
* 没有virtual关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)。
*/


#include <iostream>

using namespace std;

class Base {
public:
virtual void f(float x){ cout << "Base::f(float) " << x << endl; }
void g(float x){ cout << "Base::g(float) " << x << endl; }
void h(float x){ cout << "Base::h(float) " << x << endl; }
void m(float x){ cout << "Base::m(float) " << x << endl; }
};

class Derived : public Base {
public:
virtual void f(float x){ cout << "Derived::f(float) " << x << endl; }
void g(int x){ cout << "Derived::g(int) " << x << endl; }
void h(float x){ cout << "Derived::h(float) " << x << endl; }
void m(int x){ cout << "Derived::m(int) " << x << endl; }
};

int main(void) {
Derived d;
Base *pb = &d;
Derived *pd = &d;
// Good : behavior depends solely on type of the object
pb->f(3.14f); // Derived::f(float) 3.14
pd->f(3.14f); // Derived::f(float) 3.14
// Bad : behavior depends on type of the pointer
pb->g(3.14f); // Base::g(float) 3.14
pd->g(3.14f); // Derived::g(int) 3 (surprise!)
// Bad : behavior depends on type of the pointer
pb->h(3.14f); // Base::h(float) 3.14 (surprise!)
pd->h(3.14f); // Derived::h(float) 3.14
// Bad : behavior depends on type of the pointer
pb->m(3.14f); // Base::m(float) 3.14
pd->m(3.14f); // Derived::m(int) 3 (surprise!)
}

输出结果

注意在用不同类型的类指针调用g(),h(),m()三个函数时,程序实际的行为。

这样会带来一个问题,就是在继承后,重载了父类的一个函数,或在定义了一个函数,那么父类中与这个函数同名的函数都会被隐藏,子类的对象无法调用这些函数。

下面是一个例子

诡异的同名函数view raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 测试隐藏规则:
// 子类重载同名函数, 无论是否声明为虚函数,父类的所有同名函数将会被隐藏

#include <iostream>

using namespace std;

class Base{
public:
virtual void f(float x){ cout << "Base::f(float) " << x << endl; }
virtual void f(float x, float y){ cout << "Base::f(float, float) " << x << endl; }
};

class Derived : public Base{
public:
virtual void f(float x){ cout << "Derived::f(float) " << x << endl; }
};

int main(void){
Derived d;
Base *pb = &d;
Derived *pd = &d;
pb->f(3.14f, 3.14f);
pd->f(3.14f, 3.14f); // Compile error
}

在编译的时候会报这样的错误

总结

  1. 虚函数是通过虚表实现运行时绑定。虚表存放在对象的起始位置。子类继承父类时,会将所有的虚表就继承下来,所有子类可能有多个虚表指针。如果子类重载了父类的某个虚函数,那么子类将重写所有虚表中该函数的地址,子类将自己的虚函数添加到第一个虚表的最后。
  2. 构造函数不能声明为虚函数,析构函数可以声明为虚函数,当类包含是虚函数的成员函数时,析构函数必须声明为虚函数
  3. 当子类和父类有同名函数时,父类的所有与这个函数同名的函数都将被隐藏,子类的对象无法访问到。

参考

本文参考了以下文章:

  1. 陈皓.C++ 虚函数表解析
  2. C++ Virtual详解

  1. 系统为ubuntu 12.04 server 64bit, 编译器为gcc 4.6.3

  2. 程序运行在64位机器上,所以使用long进行强制转换获取指针,如果在32位服务器上,就应该用int。