个人中心
gpt4 book ai didi

关于C++对象继承中的内存布局示例详解

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 26 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章关于C++对象继承中的内存布局示例详解由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

前言 。

本文给大家介绍的是关于C++对象继承的内存布局的相关内容，分享出来供大家参考学习，在开始之前说明下，关于单继承和多继承的简单概念可参考此文章 。

以下编译环境均为：WIN32+VS2015 。

虚函数表 。

对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数.

首先先通过一个例子来引入虚函数表，假如现在有三个类如下:

?
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
class A //包含虚函数的类
{
public :
  virtual void func1()
  {}
 
  virtual void func2()
  {}
};
 
class B //空类
{};
 
class C //包含成员函数不包含成员变量的类
{
  void fun()
  {}
};
 
void Test1()
{
  cout << sizeof (A) << endl;
  cout << sizeof (B) << endl;
  cout << sizeof (C) << endl;
}

就上述的代码，将会分别输出4，1，1 。

造成A的大小为4的原因就是：在A中存放了一个指向A类的虚函数表的指针。而32位下一个指针大小为4字节，所以就为4.

A类实例化后在内存中对应如下:

关于C++对象继承中的内存布局示例详解

注：在虚函数表中用0来结尾.

通过内存中的显示我们就能知道编译器应该将虚函数表的指针存在于对象实例中最前面的位置，所以可以&a转成int*，取得虚函数表的地址，再强转成（int*）方便接下来可以每次只访问四个字节大小（虚函数表可看做是一个函数指针数组，由于32位下指针是4字节，所以转为（int*））。将取得的int*指针传给下面的打印虚函数表的函数，就能够打印出对应的地址信息.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
typedef void (*FUNC) ();
 
//int*VTavle = (int*)(*(int*)&a)
//传参完成后就可打印出对应的信息。
void PrintVTable( int * VTable)
{
  cout << " 虚表地址>" << VTable << endl;
  for ( int i = 0; VTable[i] != 0; ++i)
  {
  printf ( " 第%d个虚函数地址 :0X%x,->" , i, VTable[i]);
  FUNC f = (FUNC)VTable[i];
  f();
  }
  cout << endl;
}

接下来就来分析各种继承关系中对应的内存模型以及虚函数表 。

单继承（无虚函数覆盖） 。

?
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
class A
{
public :
  virtual void func1()
  {
  cout << "A::func1" << endl;
  }
 
  virtual void func2()
  {
  cout << "A::func2" << endl;
  }
 
public :
  int _a;
};
 
class B : public A
{
public :
  virtual void func3()
  {
  cout << "B::func3" << endl;
  }
 
  virtual void func4()
  {
  cout << "B::func4" << endl;
  }
 
public :
  int _b;
};
void Test1()
{
  B b;
  b._a = 1;
  b._b = 2;
 
  int * VTable = ( int *)(*( int *)&b);
  PrintVTable(VTable);
}

将内存中的显示和我们写的显示虚函数表对应起来如下:

关于C++对象继承中的内存布局示例详解

小结:

1）虚函数按照其声明顺序放于表中.

2）父类的虚函数在子类的虚函数前面。（由于子类单继承父类，直接使用父类的虚函数表） 。

一般继承（成员变量+虚函数覆盖） 。

在上面例子进行稍微修改，使得子类中有对父类虚函数的覆盖，进行和之前同样的测试:

?
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
class A
{
public :
  virtual void func1()
  {
  cout << "A::func1" << endl;
  }
 
  virtual void func2()
  {
  cout << "A::func2" << endl;
  }
 
public :
  int _a;
};
 
class B : public A
{
public :
  virtual void func1()
  {
  cout << "B::func1" << endl;
  }
 
  virtual void func3()
  {
  cout << "B::func3" << endl;
  }
 
public :
  int _b;
};

关于C++对象继承中的内存布局示例详解

小结:

1）覆盖的func()函数被放到了虚表中原来父类虚函数的位置.

2）没有被覆盖的函数依旧.

多重继承（成员变量+虚函数覆盖） 。

?
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
class A
{
public :
  virtual void func1()
  {
  cout << "A::func1" << endl;
  }
 
  virtual void func2()
  {
  cout << "A::func2" << endl;
  }
 
public :
  int _a;
};
 
class B
{
public :
  virtual void func3()
  {
  cout << "B::func1" << endl;
  }
 
 
public :
  int _b;
};
 
class C : public A , public B
{
  //覆盖A::func1()
  virtual void func1()
  {
  cout << "C::func1()" <<endl;
  }
 
  virtual void func4()
  {
  cout << "C::func4()" << endl;
  }
public :
  int _c;
};

再次调试观察:

关于C++对象继承中的内存布局示例详解

小结:

多重继承后的子类将与自己第一个继承的父类公用一份虚函数表。（上述例子中A为C的第一个继承类） 。

菱形继承（成员变量 + 虚函数覆盖） 。

?
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
class A
{
public :
  virtual void func1()
  {
  cout << "A::func1" << endl;
  }
 
public :
  int _a;
};
 
class B : public A
{
public :
  virtual void func2()
  {
  cout << "B::func2" << endl;
  }
 
public :
  int _b;
};
 
class C : public A
{
  virtual void func3()
  {
  cout << "C::func3()" << endl;
  }
 
public :
  int _c;
};
 
class D : public B , public C
{
  virtual void func2()
  {
  cout << "D::fun2()" << endl;
  }
 
  virtual void func4()
  {
  cout << "D::fun4()" << endl;
  }
public :
  int _d;
};
 
void Test1()
{
  D d;
  d.B::_a = 1;
  d.C::_a = 2;
  d._b = 3;
  d._c = 4;
  d._d = 5;
 
  int * VTable = ( int *)(*( int *)&d);
  PrintVTable(VTable);
}

掌握了单继承和多继承的规律，按照总结的一步步分析，就可以最终得到D的虚函数表.

关于C++对象继承中的内存布局示例详解

由于子类B继承父类A，所以B与A公用一个虚函数表，又因为B是D多继承中的第一个继承的类，所以B，D共用一个虚函数表.

菱形的虚拟继承（成员变量 + 虚函数覆盖） 。

参考下面这个例子:

?
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
class A
{
public :
  virtual void func1()
  {
  cout << "A::func1()" << endl;
  }
  virtual void func2()
  {
  cout << "A::func2()" << endl;
  }
 
public :
  int _a;
};
 
class B : virtual public A //虚继承A，覆盖func1()
{
public :
  virtual void func1()
  {
  cout << "B::func1()" << endl;
  }
  virtual void func3()
  {
  cout << "B::func3()" << endl;
  }
 
public :
  int _b;
};
 
class C : virtual public A //虚继承A，覆盖func1()
{
  virtual void func1()
  {
  cout << "C::func1()" << endl;
  }
 
  virtual void func3()
  {
  cout << "C::func3()" << endl;
  }
 
public :
  int _c;
};
 
class D : public B , public C //虚继承B，C,覆盖func1()
{
  virtual void func1()
  {
  cout << "D::func1()" << endl;
  }
 
  virtual void func4()
  {
  cout << "D::func4()" << endl;
  }
 
public :
  int _d;
};
 
typedef void (*FUNC) ();
 
void PrintVTable( int * VTable)
{
  cout << " 虚表地址>" << VTable << endl;
  for ( int i = 0; VTable[i] != 0; ++i)
  {
  printf ( " 第%d个虚函数地址 :0X%x,->" , i, VTable[i]);
  FUNC f = (FUNC)VTable[i];
  f();
  }
  cout << endl;
}
 
void Test1()
{
  D d;
  d.B::_a = 1;
  d.C::_a = 2;
  d._b = 3;
  d._c = 4;
  d._d = 5;
 
  cout << "sizeof(A) = " << sizeof (A) << endl;
  cout << "sizeof(B) = " << sizeof (B) << endl;
  cout << "sizeof(C) = " << sizeof (C) << endl;
 
  //打印d的虚函数表
  int * VTable = ( int *)(*( int *)&d);
  PrintVTable(VTable);
 
  //打印C的虚函数表
  VTable = ( int *)*( int *)(( char *)&d + sizeof (B)- sizeof (A));
  PrintVTable(VTable);
 
  //打印A的虚函数表
  VTable = ( int *)*( int *)(( char *)&d + sizeof (B)+ sizeof (C)-2* sizeof (A)+4);
  PrintVTable(VTable);
 
}

接下来就慢慢分析:

1）先通过调试查看内存中是如何分配的，并和我们打印出的虚函数表对应起来:

关于C++对象继承中的内存布局示例详解

注：由于B，C是虚继承A，所以编译器为了解决菱形继承所带来的“二义性”以及“数据冗余”，便将A放在最末端，并在子类中存放一个虚基表，方便找到父类；而虚基表的前四个字节存放的是对于自己虚函数表的偏移量，再往下四个字节才是对于父类的偏移量.

2）接下来就抽象出来分析模型 。

关于C++对象继承中的内存布局示例详解

总结 。

1）虚函数按照其声明顺序放于表中； 。

2）父类的虚函数在子类的虚函数前面（由于子类单继承父类，直接使用父类的虚函数表）； 。

3）覆盖的func()函数被放到了虚表中原来父类虚函数的位置； 。

4）没有被覆盖的函数依旧； 。

5）如果B，C虚继承A，并且B，C内部没有再声明或定义虚函数，则B，C没有对应的虚函数表； 。

6）在菱形的虚拟继承中，要注意A为B，C所共有的，在打印对应虚函数表时要注意偏移量.

好了，以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对我的支持.

原文链接：http://blog.csdn.net/sssssuuuuu666/article/details/76125155 。

最后此篇关于关于C++对象继承中的内存布局示例详解的文章就讲到这里了,如果你想了解更多关于关于C++对象继承中的内存布局示例详解的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

26 4 0
文章推荐： php tpl模板引擎定义与使用示例
文章推荐： java基础的详细了解第八天
文章推荐： SparkSQL简介及运行原理
文章推荐： php函数式编程简单示例
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com