c++对象模型

2022-12-09 c++ 0 评论字数统计: 10.1k(字) 阅读时长: 46(分)

前言

看此篇文档前需要先弄清楚指针地址的强制转换和内存对齐知识

从下面这个例子引入强制转换的概念:

struct test{
	char string[2];  //2
	int *point;   //4
	int nu[2];    //8
	short data[3];  //6
}*p;

如果p 的值为0x100000。如下表表达式的值分别为多少？

p + 0x01 = 
(unsigned long)p + 0x01 = 
(unsigned int*)p + 0x01 =

分析实例

主要的原理还是表达式“a+1”与“&a+1”之间的区别，同理，指针变量与一个整数相加减并不是用指针变量里的地址直接加减这个整数。这个整数的单位不是byte 而是元素的个数。

Q1: p + 0x1 的值为0x100000+sizof(test)0x1。至于此结构体的大小为20byte，所以p +0x1 的值为：0x100014;
Q2: (unsigned long)p + 0x1 的值呢？这里涉及到强制转换，将指针变量p 保存的值强制转换成无符号的长整型数。任何数值一旦被强制转换，其类型就改变了。所以这个表达式其实就是一个无符号的长整型数加上另一个整数。所以其值为:0x100001;
Q3:(unsigned int*)p + 0x1 的值呢？这里的p 被强制转换成一个指向无符号整型的指针。所以其值为：0x100000+sizof(unsigned int)*0x1，等于0x100004;

实例解析

#include <stdio.h>
int main()
{
	int a[4] = { 1,2,3,4 };

	int* p1 = (int*)(&a + 1);
	int* p2 = (int*)((int)a + 1);

	printf("The a address is %p\n", &a);
	printf("The a+1 address is %p\n", &(a[1]));
	printf("The (int)a address is %p\n", (int)a);
	printf("The (int)a+1 address is %p\n", (int)a + 1);
	printf("%x %p %x\n", p1[-1], p2, *p2);

	return 0;
}

The a address is 004FFD18
The a+1 address is 004FFD1C
The (int)a address is 004FFD18
The (int)a+1 address is 004FFD19
4 004FFD19 2000000

这个p1[-1]是4,是因为sizeof(a)= 16，&a+1就是a数组的末尾了

p2就是将a的地址转成int后+1=004FFD18+1=004FFD19

*p2的值应该为&a+sizeof(int)*0x01的值，我们可以通过VS查看内存布局；

vs内存

由内存中数据可知当前数据的存储方式为小端模式
p2的地址是004FFD19，内存的数据是00 00 00 02，由于是小端模式，所以最后的数值是02 00 00 00

大小端介绍

类对象地址获取内部变量

对于类内部变量可以通过强转类对象地址拿到

图 1

a:  *(int*)&aaa
b:  *((int*)&aaa + 1)

对于成员函数可以定义成员函数的函数指针强转拿到

具体可以查看成员函数

成员函数是在编译器就确定好的，当成全局函数来调用
https://blog.csdn.net/baidu_41388533/article/details/109564682

1.何为C++对象模型?

引用《深度探索C++对象模型》这本书中的话：

有两个概念可以解释C++对象模型：
1、语言中直接支持面向对象程序设计的部分。
2、对于各种支持的底层实现机制。

直接支持面向对象程序设计，包括了构造函数、析构函数、多态、虚函数等等，这些内容在很多书籍上都有讨论，也是C++最被人熟知的地方（特性）。而对象模型的底层实现机制却是很少有书籍讨论的。对象模型的底层实现机制并未标准化，不同的编译器有一定的自由来设计对象模型的实现细节。在我看来，对象模型研究的是对象在存储上的空间与时间上的更优，并对C++面向对象技术加以支持，如以虚指针、虚表机制支持多态特性。

2.文章内容简介

这篇文章主要来讨论C++对象在内存中的布局，属于第二个概念的研究范畴。而C++直接支持面向对象程序设计部分则不多讲。文章主要内容如下：

虚函数表解析。含有虚函数或其父类含有虚函数的类，编译器都会为其添加一个虚函数表,vptr，先了解虚函数表的构成，有助对C++对象模型的理解。
虚基类表解析。虚继承产生虚基类表(vbptr)，虚基类表的内容与虚函数表完全不同，我们将在讲解虚继承时介绍虚函数表。
对象模型概述：介绍简单对象模型、表格驱动对象模型，以及非继承情况下的C++对象模型。
继承下的C++对象模型。分析C++类对象在下面情形中的内存布局：
- 单继承：子类单一继承自父类，分析了子类重写父类虚函数、子类定义了新的虚函数情况下子类对象内存布局。
- 多继承：子类继承于多个父类，分析了子类重写父类虚函数、子类定义了新的虚函数情况下子类对象内存布局，同时分析了非虚继承下的菱形继承。
- 虚继承：分析了单一继承下的虚继承、多重基层下的虚继承、重复继承下的虚继承。
理解对象的内存布局之后，我们可以分析一些问题：
- C++封装带来的布局成本是多大？
- 由空类组成的继承层次中，每个类对象的大小是多大？

至于其他与内存有关的知识，我假设大家都有一定的了解，如内存对齐，指针操作等。本文初看可能晦涩难懂，要求读者有一定的C++基础，对概念一有一定的掌握。

3.理解虚函数表

3.1.多态与虚表

C++中虚函数的作用主要是为了实现多态机制。多态，简单来说，是指在继承层次中，父类的指针可以具有多种形态——当它指向某个子类对象时，通过它能够调用到子类的函数，而非父类的函数。

class Base {     virtual void print(void);    }
class Drive1 :public Base{    virtual void print(void);    }
class Drive2 :public Base{    virtual void print(void);    }

Base * ptr1 = new Base; 
Base * ptr2 = new Drive1;  
Base * ptr3 = new Drive2;

ptr1->print(); //调用Base::print()
prt2->print();//调用Drive1::print()
prt3->print();//调用Drive2::print()

这是一种运行期多态，即父类指针唯有在程序运行时才能知道所指的真正类型是什么。这种运行期决议，是通过虚函数表来实现的。

3.2.使用指针访问虚表

如果我们丰富我们的Base类,使其拥有多个virtual函数：

当一个类本身定义了虚函数，或其父类有虚函数时，为了支持多态机制，编译器将为该类添加一个虚函数指针（vptr）。虚函数指针一般都放在对象内存布局的第一个位置上，这是为了保证在多层继承或多重继承的情况下能以最高效率取到虚函数表。

当vprt位于对象内存最前面时，对象的地址即为虚函数指针地址。我们可以取得虚函数指针的地址：

如下的例子

#pragma once
#include<iostream>
using namespace std;
class Base
{
public:

	Base(int i) :baseI(i) {};
	virtual void print(void) { cout << "调用了虚函数Base::print()" << endl; }
	virtual void setI() { cout << "调用了虚函数Base::setI()" << endl; }
	virtual ~Base() {}
private:
	int baseI;
};

int main()
{
	Base b(100);
	int* vptrAdree = (int*)(&b);
	cout << "虚函数指针（vprt）的地址是：\t" << vptrAdree << endl;
	cout << "baseI的值是："<<*(vptrAdree + 1) << "	变量的地址是：" << vptrAdree + 1 << endl;

	typedef void(*Fun)(void);
	Fun vfunc = (Fun) * ((int*)*(int*)(&b));
	cout << "第一个虚函数的地址是：" << (int*)*(int*)(&b) << endl;
	cout << "通过地址，调用虚函数Base::print()：" ;
	vfunc();
	cout << "第二个虚函数的地址是：" << (int*)*(int*)(&b) + 1 << endl;
	cout << "通过地址，调用虚函数Base::setI()：";
	((Fun)* ((int*)*(int*)(&b) + 1))();

	return 0;
}

结果如下：
虚函数指针（vprt）的地址是：    00FBFBE4
baseI的值是：100        变量的地址是：00FBFBE8
第一个虚函数的地址是：000DAB34
通过地址，调用虚函数Base::print()：调用了虚函数Base::print()
第二个虚函数的地址是：000DAB38
通过地址，调用虚函数Base::setI()：调用了虚函数Base::setI()

我们强行把类对象的地址转换为 int* 类型，取得了虚函数指针的地址。虚函数指针指向虚函数表,虚函数表中存储的是一系列虚函数的地址，虚函数地址出现的顺序与类中虚函数声明的顺序一致。对虚函数指针地址值，可以得到虚函数表的地址，也即是虚函数表第一个虚函数的地址:

我们把虚表指针的值取出来： (int)(&b)，它是一个地址，虚函数表的地址
把虚函数表的地址强制转换成 int* : ( int *) ( int )( &b )
再把它转化成我们Fun指针类型： (Fun )(int )(int)(&b)

这样，我们就取得了类中的第一个虚函数，我们可以通过函数指针访问它。
同理可以拿到第二个虚函数的地址

4.对象模型概述

在C++中，有两种数据成员（class data members）：static 和nonstatic,以及三种类成员函数（class member functions）:static、nonstatic和virtual:

图 2

现在我们有一个类Base，它包含了上面这5中类型的数据或函数：

class Base
{
public: 
    Base(int i) :baseI(i){};  
    int getI(){ return baseI; } 
    static void countI(){}; 
    virtual ~Base(){}
    virtual void print(void){ cout << "Base::print()"; }    
private: 
    int baseI; 
    static int baseS;
};

那么，这个类在内存中将被如何表示？5种数据都是连续存放的吗？如何布局才能支持C++多态？我们的C++标准与编译器将如何塑造出各种数据成员与成员函数呢？

4.1.简单对象模型

说明：在下面出现的图中，用蓝色边框框起来的内容在内存上是连续的。

这个模型非常地简单粗暴。在该模型下，对象由一系列的指针组成，每一个指针都指向一个数据成员或成员函数，也即是说，每个数据成员和成员函数在类中所占的大小是相同的，都为一个指针的大小。这样有个好处——很容易算出对象的大小，不过赔上的是空间和执行期效率。想象一下，如果我们的Point3d类是这种模型，将会比C语言的struct多了许多空间来存放指向函数的指针，而且每次读取类的数据成员，都需要通过再一次寻址——又是时间上的消耗。
所以这种对象模型并没有被用于实际产品上。

图 3

4.2.表格驱动模型

这个模型在简单对象模型的基础上又添加一个间接层，它把类中的数据分成了两个部分：数据部分与函数部分，并使用两张表格，一张存放数据本身，一张存放函数的地址（也即函数比成员多一次寻址），而类对象仅仅含有两个指针，分别指向上面这两个表。这样看来，对象的大小是固定为两个指针大小。这个模型也没有用于实际应用于真正的C++编译器上。

4.3.非继承下的C++对象模型

概述：在此模型下，nonstatic 数据成员被置于每一个类对象中，而static数据成员被置于类对象之外。static与nonstatic函数也都放在类对象之外，而对于virtual 函数，则通过虚函数表+虚指针来支持，具体如下：

每个类生成一个表格，称为虚表（virtual table，简称vtbl）。虚表中存放着一堆指针，这些指针指向该类每一个虚函数。虚表中的函数地址将按声明时的顺序排列，不过当子类有多个重载函数时例外，后面会讨论。
每个类对象都拥有一个虚表指针(vptr)，由编译器为其生成。虚表指针的设定与重置皆由类的复制控制（也即是构造函数、析构函数、赋值操作符）来完成。vptr的位置为编译器决定，传统上它被放在所有显示声明的成员之后，不过现在许多编译器把vptr放在一个类对象的最前端。关于数据成员布局的内容，在后面会详细分析。
另外，虚函数表的前面设置了一个指向type_info的指针，用以支持RTTI（Run Time Type Identification，运行时类型识别）。RTTI是为多态而生成的信息，包括对象继承关系，对象本身的描述等，只有具有虚函数的对象在会生成。

在此模型下，Base的对象模型如图：
图 4

先在VS上验证类对象的布局：

Base b(1000);

图 5

可见对象b含有一个vfptr，即vprt。并且只有nonstatic数据成员被放置于对象内。我们展开vfprt：
图 6

vfptr中有两个指针类型的数据（地址），第一个指向了Base类的析构函数，第二个指向了Base的虚函数print，顺序与声明顺序相同。

这与上述的C++对象模型相符合。也可以通过代码来进行验证：

#include <windows.h>
#include <typeinfo>
#include <iostream>
using namespace std;

typedef unsigned long DWORD;
struct TypeDescriptor
{
	DWORD ptrToVTable;
	DWORD spare;
	char name[8];
};
struct PMD
{
	int mdisp;  //member displacement
	int pdisp;  //vbtable displacement
	int vdisp;  //displacement inside vbtable
};
struct RTTIBaseClassDescriptor
{
	struct TypeDescriptor* pTypeDescriptor; //type descriptor of the class
	DWORD numContainedBases; //number of nested classes following in the Base Class Array
	struct PMD where;        //pointer-to-member displacement info
	DWORD attributes;        //flags, usually 0
};

struct RTTIClassHierarchyDescriptor
{
	DWORD signature;      //always zero?
	DWORD attributes;     //bit 0 set = multiple inheritance, bit 1 set = virtual inheritance
	DWORD numBaseClasses; //number of classes in pBaseClassArray
	struct RTTIBaseClassArray* pBaseClassArray;
};

struct RTTICompleteObjectLocator
{
	DWORD signature; //always zero ?
	DWORD offset;    //offset of this vtable in the complete class
	DWORD cdOffset;  //constructor displacement offset
	struct TypeDescriptor* pTypeDescriptor; //TypeDescriptor of the complete class
	struct RTTIClassHierarchyDescriptor* pClassDescriptor; //describes inheritance hierarchy
};

class Base
{
public:
	Base(int i) :baseI(i) {};
	int getI() { return baseI; }
	static void countI() {};
	virtual ~Base() {}
	virtual void print(void) { cout << "Base::print()"; }
private:
	int baseI;
	static int baseS;
};

void testBase(Base& p)
{
	cout << "对象的内存起始地址：" << &p << endl;
	cout << "type_info信息:" << endl;
	RTTICompleteObjectLocator str = *((RTTICompleteObjectLocator*)*((int*)*(int*)(&p) - 1));

	string classname(str.pTypeDescriptor->name);
	classname = classname.substr(4, classname.find("@@") - 4);
	cout << "根据type_info信息输出类名:" << classname << endl;

	cout << "虚函数表地址:" << (int*)(&p) << endl;

	//验证虚表
	cout << "虚函数表第一个函数的地址：" << (int*)*((int*)(&p)) << endl;
	cout << "析构函数的地址:" << (int*)*(int*)*((int*)(&p)) << endl;
	cout << "虚函数表中，第二个虚函数即print（）的地址：" << ((int*)*(int*)(&p) + 1) << endl;

	//通过地址调用虚函数print（）
	typedef void(*Fun)(void);
	Fun IsPrint = (Fun)*((int*)*(int*)(&p) + 1);
	cout << endl;
	cout << "调用了虚函数";
	IsPrint(); //若地址正确，则调用了Base类的虚函数print（）
	cout << endl;

	//输入static函数的地址
	p.countI();//先调用函数以产生一个实例
	cout << "static函数countI()的地址：" << p.countI << endl;

	//验证nonstatic数据成员
	cout << "推测nonstatic数据成员baseI的地址：" << (int*)(&p) + 1 << endl;
	cout << "根据推测出的地址，输出该地址的值：" << *((int*)(&p) + 1) << endl;
	cout << "Base::getI():" << p.getI() << endl;
}

int main()
{
	Base b(5);
	testBase(b);
	
	return 0;
}

对象的内存起始地址：00F5FE0C
type_info信息:
根据type_info信息输出类名:Base
虚函数表地址:00F5FE0C
虚函数表第一个函数的地址：00221B34
析构函数的地址:0021168B
虚函数表中，第二个虚函数即print（）的地址：00221B38

调用了虚函数调用了虚函数Base::setI()

static函数countI()的地址：00211316
推测nonstatic数据成员baseI的地址：00F5FE10
根据推测出的地址，输出该地址的值：5
Base::getI():5

结果分析：

通过 (int *)(&p)取得虚函数表的地址
type_info信息的确存在于虚表的前一个位置。通过((int)(int*)(&p) - 1))取得type_infn信息，并成功获得类的名称的Base
虚函数表的第一个函数是析构函数。
虚函数表的第二个函数是虚函数print()，取得地址后通过地址调用它（而非通过对象），验证正确
虚表指针的下一个位置为nonstatic数据成员baseI。
可以看到，static成员函数的地址段位与虚表指针、baseI的地址段位不同。

好的，至此我们了解了非继承下类对象五种数据在内存上的布局，也知道了在每一个虚函数表前都有一个指针指向type_info，负责对RTTI的支持。而加入继承后类对象在内存中该如何表示呢？

5.继承下的C++对象模型

5.1.单继承

如果我们定义了派生类

class Derive : public Base
{
public:
    Derive(int d) :Base(1000),      DeriveI(d){};
    //overwrite父类虚函数
    virtual void print(void){ cout << "Drive::Drive_print()" ; }
    // Derive声明的新的虚函数
        virtual void Drive_print(){ cout << "Drive::Drive_print()" ; }
    virtual ~Derive(){}
private:
    int DeriveI;
};

一个派生类如何在机器层面上塑造其父类的实例呢？在简单对象模型中，可以在子类对象中为每个基类子对象分配一个指针。如下图：

图 7

简单对象模型的缺点就是因间接性导致的空间存取时间上的额外负担，优点则是类的大小是固定的，基类的改动不会影响子类对象的大小。

在表格驱动对象模型中，我们可以为子类对象增加第三个指针：基类指针(bptr)，基类指针指向指向一个基类表(base class table),同样的，由于间接性导致了空间和存取时间上的额外负担，优点则是无须改变子类对象本身就可以更改基类。表格驱动模型的图就不再贴出来了。

在C++对象模型中，对于一般继承（这个一般是相对于虚拟继承而言），若子类重写（overwrite）了父类的虚函数，则子类虚函数将覆盖虚表中对应的父类虚函数(注意子类与父类拥有各自的一个虚函数表)；若子类并无overwrite父类虚函数，而是声明了自己新的虚函数，则该虚函数地址将扩充到虚函数表最后（在vs中无法通过监视看到扩充的结果，不过我们通过取地址的方法可以做到，子类新的虚函数确实在父类子物体的虚函数表末端）。而对于虚继承，若子类overwrite父类虚函数，同样地将覆盖父类子物体中的虚函数表对应位置，而若子类声明了自己新的虚函数，则编译器将为子类增加一个新的虚表指针vptr，这与一般继承不同,在后面再讨论。

图 8

我们使用代码来验证以上模型

#include <iostream>
using namespace std;

class Base
{
public:

	Base(int i) :baseI(i) {};
	int getI() { return baseI; }
	static void countI() {};
	virtual void print(void) { cout << "Base::print()"; }
	virtual ~Base() {}
private:
	int baseI;
	static int baseS;
};

class Derive : public Base
{
public:
	Derive(int d) :Base(1000), DeriveI(d) {};
	//overwrite父类虚函数
	virtual void print(void) { cout << "Drive::Drive_print()"; }
	// Derive声明的新的虚函数
	virtual void Drive_print() { cout << "Drive::Drive_print()"; }
	virtual ~Derive() {}
private:
	int DeriveI;
};

typedef void(*Fun)(void);

int main()
{
	Derive d(2000);
	//[0]
	cout << "[0]Base::vptr";
	cout << "\t地址：" << (int*)(&d) << endl;
		//vprt[0]
		cout << "  [0]";
		Fun fun1 = (Fun) * ((int*)*((int*)(&d)));
		fun1();
		cout << "\t地址:\t" << ((int*)*((int*)(&d))) << endl;

		//vprt[1]析构函数无法通过地址调用，故手动输出
		cout << "  [1]" << "Derive::~Derive \t" << "\t地址：\t" <<(int*)*(int*)&d + 1 << endl;

		//vprt[2]
		cout << "  [2]";
		Fun fun2 = (Fun) * ((int*)*((int*)(&d)) + 2);
		fun2();
		cout << "\t地址:\t" << ((int*)*((int*)(&d)) + 2) << endl;
	//[1]
	cout << "[1]Base::baseI=" << *(int*)((int*)(&d) + 1);
	cout << "\t地址：" << (int*)(&d) + 1;
	cout << endl;
	//[2]
	cout << "[2]Derive::DeriveI=" << *(int*)((int*)(&d) + 2);
	cout << "\t地址：" << (int*)(&d) + 2;
	cout << endl;
	getchar();
}

运行结果：与我们的对象模型符合

[0]Base::vptr   地址：003EFE60
  [0]Drive::Drive_print()       地址:   00143918
  [1]Derive::~Derive            地址：  0014391C
  [2]Drive::Drive_print()       地址:   00143920
[1]Base::baseI=1000     地址：003EFE64
[2]Derive::DeriveI=2000 地址：003EFE68

5.2.多继承

5.2.1一般的多重继承（非菱形继承）

单继承中（一般继承），子类会扩展父类的虚函数表。在多继承中，子类含有多个父类的子对象，该往哪个父类的虚函数表扩展呢？当子类overwrite了父类的函数，需要覆盖多个父类的虚函数表吗？

子类的虚函数被放在声明的第一个基类的虚函数表中。
overwrite时，所有基类的print()函数都被子类的print()函数覆盖。
内存布局中，父类按照其声明顺序排列。

其中第二点保证了父类指针指向子类对象时，总是能够调用到真正的函数。

继承类图为：

图 2

此时Drive_multyBase 的对象模型是这样的：
图 1

我们使用代码验证：

#include <iostream>
using namespace std;

class Base
{
public:
	Base(int i) :baseI(i) {};
	virtual ~Base() {}
	int getI() { return baseI; }
	static void countI() {};
	virtual void print(void) { cout << "Base::print()"; }
private:
	int baseI;
	static int baseS;
};

class Base_2
{
public:
	Base_2(int i) :base2I(i) {};
	virtual ~Base_2() {}
	int getI() { return base2I; }
	static void countI() {};
	virtual void print(void) { cout << "Base_2::print()"; }
private:
	int base2I;
	static int base2S;
};

class Drive_multyBase :public Base, public Base_2
{
public:

	Drive_multyBase(int d) :Base(1000), Base_2(2000), Drive_multyBaseI(d) {};
	virtual void print(void) { cout << "Drive_multyBase::print"; }
	virtual void Drive_print() { cout << "Drive_multyBase::Drive_print"; }
private:
	int Drive_multyBaseI;
};

typedef void(*Fun)(void);

int main()
{
	Drive_multyBase d(3000);
	//[0]
	cout << "[0]Base::vptr";
	cout << "\t地址：" << (int*)(&d) << endl;

		//vprt[0]析构函数无法通过地址调用，故手动输出
		cout << "  [0]" << "Derive::~Derive\t" << "\t地址:\t" << (int*)*((int*)(&d)) << endl;

		//vprt[1]
		cout << "  [1]";
		Fun fun1 = (Fun) * ((int*)*((int*)(&d)) + 1);
		fun1();
		cout << "\t地址:\t" << ((int*)*((int*)(&d)) + 1) << endl;


		//vprt[2]
		cout << "  [2]";
		Fun fun2 = (Fun) * ((int*)*((int*)(&d)) + 2);
		fun2();
		cout << "\t地址:\t" << ((int*)*((int*)(&d)) + 2) << endl;

	//[1]
	cout << "[1]Base::baseI=" << *(int*)((int*)(&d) + 1);
	cout << "\t地址：" << (int*)(&d) + 1;
	cout << endl;

	//[2]
	cout << "[2]Base_2::vptr";
	cout << "\t地址：" << (int*)(&d) + 2 << endl;

		//vprt[0]析构函数无法通过地址调用，故手动输出
		cout << "  [0]" << "Drive_multyBase::~Derive\t" << "\t地址:\t" << (int*)*((int*)(&d) + 2) << endl;

		//vprt[1]
		cout << "  [1]";
		Fun fun4 = (Fun) * ((int*)*(int*)((int*)(&d) + 2) + 1);
		fun4();
		cout << "\t地址:\t" << ((int*)*((int*)(&d) + 2) + 1) << endl;

	//[3]
	cout << "[3]Base_2::base2I=" << *(int*)((int*)(&d) + 3);
	cout << "\t地址：" << (int*)(&d) + 3;
	cout << endl;

	//[4]
	cout << "[4]Drive_multyBase::Drive_multyBaseI=" << *(int*)((int*)(&d) + 4);
	cout << "\t地址：" << (int*)(&d) + 4;
	cout << endl;

	getchar();

	return 0;
}

结果输出：

[0]Base::vptr   地址：007CF804
  [0]Derive::~Derive            地址:   001549FC
  [1]Drive_multyBase::print     地址:   00154A00
  [2]Drive_multyBase::Drive_print       地址:   00154A04
[1]Base::baseI=1000     地址：007CF808
[2]Base_2::vptr 地址：007CF80C
  [0]Drive_multyBase::~Derive           地址:   00154A10
  [1]Drive_multyBase::print     地址:   00154A14
[3]Base_2::base2I=2000  地址：007CF810
[4]Drive_multyBase::Drive_multyBaseI=3000       地址：007CF814

5.2.2 菱形继承

菱形继承也称为钻石型继承或重复继承，它指的是基类被某个派生类简单重复继承了多次。这样，派生类对象中拥有多份基类实例（这会带来一些问题）。为了方便叙述，我们不使用上面的代码了，而重新写一个重复继承的继承层次：

图 3

#include <iostream>
using namespace std;

class B
{
public:
	int ib;
public:
	B(int i = 1) :ib(i) {}
	virtual void f() { cout << "B::f()"; }
	virtual void Bf() { cout << "B::Bf()"; }
};

class B1 : public B
{
public:
	int ib1;
public:
	B1(int i = 100) :ib1(i) {}
	virtual void f() { cout << "B1::f()"; }
	virtual void f1() { cout << "B1::f1()"; }
	virtual void Bf1() { cout << "B1::Bf1()"; }
};

class B2 : public B
{
public:
	int ib2;
public:
	B2(int i = 1000) :ib2(i) {}
	virtual void f() { cout << "B2::f()"; }
	virtual void f2() { cout << "B2::f2()"; }
	virtual void Bf2() { cout << "B2::Bf2()"; }
};


class D : public B1, public B2
{
public:
	int id;
public:
	D(int i = 10000) :id(i) {}
	virtual void f() { cout << "D::f()"; }
	virtual void f1() { cout << "D::f1()"; }
	virtual void f2() { cout << "D::f2()"; }
	virtual void Df() { cout << "D::Df()"; }
};

typedef void(*Fun)(void);

int main()
{
	D d;

	//d.ib = 1;					//编译器提示报错，二义性错误,调用的是B1的ib还是B2的ib？
	d.B1::ib = 1;				//正确
	d.B2::ib = 1;				//正确

	//d.Bf();					//编译器提示报错，二义性错误,调用的是B1的ib还是B2的ib？
	d.B1::Bf();					//正确
	d.B2::Bf();					//正确

	cout << endl;
	cout << endl;

	//[0]
	cout << "[0]B1::vptr";
	cout << "\t地址：" << (int*)(&d) << endl;
	{
		//vprt[0]
		cout << "  [0]";
		Fun df = (Fun) * ((int*)*((int*)(&d)));
		df();
		cout << "\t地址:\t" << ((int*)*((int*)(&d))) << endl;

		//vprt[1]
		cout << "  [1]";
		Fun bf = (Fun) * ((int*)*((int*)(&d)) + 1);
		bf();
		cout << "\t地址:\t" << ((int*)*((int*)(&d)) + 1) << endl;

		//vprt[2]
		cout << "  [2]";
		Fun df1 = (Fun) * ((int*)*((int*)(&d)) + 2);
		df1();
		cout << "\t地址:\t" << ((int*)*((int*)(&d)) + 2) << endl;

		//vprt[3]
		cout << "  [3]";
		Fun bf1 = (Fun) * ((int*)*((int*)(&d)) + 3);
		bf1();
		cout << "\t地址:\t" << ((int*)*((int*)(&d)) + 3) << endl;

		//vprt[4]
		cout << "  [4]";
		Fun ddf = (Fun) * ((int*)*((int*)(&d)) + 4);
		ddf();
		cout << "\t地址:\t" << ((int*)*((int*)(&d)) + 4) << endl;

	}
	//[1]
	cout << "[1]B::ib=" << *((int*)(&d) + 1);
	cout << "\t地址：" << (int*)(&d) + 1;
	cout << endl;

	//[2]
	cout << "[2]B1::ib1=" << *((int*)(&d) + 2);
	cout << "\t地址：" << (int*)(&d) + 2;
	cout << endl;

	//[3]
	cout << "[3]B2::vptr";
	cout << "\t地址：" << (int*)(&d) + 3 << endl;
	{
		//vprt[0]
		cout << "  [0]";
		Fun df = (Fun) * ((int*)*(int*)((int*)(&d) + 3));
		df();
		cout << "\t地址:\t" << ((int*)*((int*)(&d) + 3)) << endl;

		//vprt[1]
		cout << "  [1]";
		Fun bf = (Fun) * ((int*)*(int*)((int*)(&d) + 3) + 1);
		bf();
		cout << "\t地址:\t" << ((int*)*((int*)(&d) + 3) + 1) << endl;

		//vprt[2]
		cout << "  [2]";
		Fun df1 = (Fun) * ((int*)*(int*)((int*)(&d) + 3) + 2);
		df1();
		cout << "\t地址:\t" << ((int*)*((int*)(&d) + 3) + 2) << endl;

		//vprt[3]
		cout << "  [3]";
		Fun bf2 = (Fun) * ((int*)*(int*)((int*)(&d) + 3) + 3);
		bf2();
		cout << "\t地址:\t" << ((int*)*((int*)(&d) + 3) + 3) << endl;

	}
	//[4]
	cout << "[4]B::ib=" << *((int*)(&d) + 4);
	cout << "\t地址：" << (int*)(&d) + 4;
	cout << endl;

	//[5]
	cout << "[5]B2::ib2=" << *((int*)(&d) + 5);
	cout << "\t地址：" << (int*)(&d) + 5;
	cout << endl;

	//[6]
	cout << "[6]D::id=" << *((int*)(&d) + 6);
	cout << "\t地址：" << (int*)(&d) + 6;
	cout << endl;

	return 0;
}

这时，根据单继承，我们可以分析出B1，B2类继承于B类时的内存布局。又根据一般多继承，我们可以分析出D类的内存布局。我们可以得出D类子对象的内存布局如下图：
图 3

D类对象内存布局中，图中青色表示b1类子对象实例，黄色表示b2类子对象实例，灰色表示D类子对象实例。从图中可以看到，由于D类间接继承了B类两次，导致D类对象中含有两个B类的数据成员ib，一个属于来源B1类，一个来源B2类。这样不仅增大了空间，更重要的是引起了程序歧义：

B::Bf()B::Bf()

[0]B1::vptr     地址：006FFB1C
  [0]D::f()     地址:   00C24B8C
  [1]B::Bf()    地址:   00C24B90
  [2]D::f1()    地址:   00C24B94
  [3]B1::Bf1()  地址:   00C24B98
  [4]D::Df()    地址:   00C24B9C
[1]B::ib=1      地址：006FFB20
[2]B1::ib1=100  地址：006FFB24
[3]B2::vptr     地址：006FFB28
  [0]D::f()     地址:   00C24BA8
  [1]B::Bf()    地址:   00C24BAC
  [2]D::f2()    地址:   00C24BB0
  [3]B2::Bf2()  地址:   00C24BB4
[4]B::ib=1      地址：006FFB2C
[5]B2::ib2=1000 地址：006FFB30
[6]D::id=10000  地址：006FFB34

尽管我们可以通过明确指明调用路径以消除二义性，但二义性的潜在性还没有消除，我们可以通过虚继承来使D类只拥有一个ib实体。

6.虚继承

虚继承解决了菱形继承中最派生类拥有多个间接父类实例的情况。虚继承的派生类的内存布局与普通继承很多不同，主要体现在：

虚继承的子类，如果本身定义了新的虚函数，则编译器为其生成一个虚函数指针（vptr）以及一张虚函数表。该vptr位于对象内存最前面。 vs非虚继承：直接扩展父类虚函数表。
虚继承的子类也单独保留了父类的vprt与虚函数表。这部分内容接与子类内容以一个四字节的0来分界。
虚继承的子类对象中，含有四字节的虚表指针偏移值。

为了分析最后的菱形继承，我们还是先从单虚继承继承开始。

6.1.虚基类表解析

在C++对象模型中，虚继承而来的子类会生成一个隐藏的虚基类指针（vbptr），在Microsoft Visual C++中，虚基类表指针总是在虚函数表指针之后，因而，对某个类实例来说，如果它有虚基类指针，

那么虚基类指针可能在实例的0字节偏移处（该类没有vptr时，vbptr就处于类实例内存布局的最前面，否则vptr处于类实例内存布局的最前面），也可能在类实例的4字节偏移处。

一个类的虚基类指针指向的虚基类表，与虚函数表一样，虚基类表也由多个条目组成，条目中存放的是偏移值。第一个条目存放虚基类表指针（vbptr）所在地址到该类内存首地址的偏移值，由第一段的分析我们知道，这个偏移值为0（类没有vptr）或者-4（类有虚函数，此时有vptr）。我们通过一张图来更好地理解。

图 5

图 4

虚基类表的第二、第三…个条目依次为该类的最左虚继承父类、次左虚继承父类…的内存地址相对于虚基类表指针的偏移值，这点我们在下面会验证。

6.2.简单虚继承

如果我们的B1类虚继承于B类：

1
2
3

//类的内容与前面相同
class B{...}
class B1 : virtual public B

图 6

根据我们前面对虚继承的派生类的内存布局的分析，B1类的对象模型应该是这样的：
图 7

我们通过指针访问B1类对象的内存，以验证上面的C++对象模型：

#include <iostream>
using namespace std;

class B
{
public:
	int ib;
public:
	B(int i = 1) :ib(i) {}
	virtual void f() { cout << "B::f()"; }
	virtual void Bf() { cout << "B::Bf()"; }
};

class B1 : virtual public B
{
public:
	int ib1;
public:
	B1(int i = 100) :ib1(i) {}
	virtual void f() { cout << "B1::f()"; }
	virtual void f1() { cout << "B1::f1()"; }
	virtual void Bf1() { cout << "B1::Bf1()"; }
};

typedef void(*Fun)(void);
int main()
{
	B1 a;
	cout << "B1对象内存大小为：" << sizeof(a) << endl;

	//取得B1的虚函数表
	cout << "[0]B1::vptr";
	cout << "\t地址：" << (int*)(&a) << endl;

	//输出虚表B1::vptr中的函数
	for (int i = 0; i < 2; ++i)
	{
		cout << "  [" << i << "]";
		Fun fun1 = (Fun) * ((int*)*(int*)(&a) + i);
		fun1();
		cout << "\t地址：\t" << *((int*)*(int*)(&a) + i) << endl;
	}

	//[1]
	cout << "[1]vbptr ";
	cout << "\t地址：" << (int*)(&a) + 1 << endl;  //虚表指针的地址
	//输出虚基类指针条目所指的内容
	for (int i = 0; i < 2; i++)
	{
		cout << "  [" << i << "]";
		cout << *(int*)((int*)*((int*)(&a) + 1) + i);
		cout << endl;
	}

	//[2]
	cout << "[2]B1::ib1=" << *(int*)((int*)(&a) + 2);
	cout << "\t地址：" << (int*)(&a) + 2;
	cout << endl;

	//[3]
	cout << "[3]值=" << *(int*)((int*)(&a) + 3);
	cout << "\t\t地址：" << (int*)(&a) + 3;
	cout << endl;

	//[4]
	cout << "[4]B::vptr";
	cout << "\t地址：" << (int*)(&a) + 3 << endl;

	//输出B::vptr中的虚函数
	for (int i = 0; i < 2; ++i)
	{
		cout << "  [" << i << "]";
		Fun fun1 = (Fun) * ((int*)*((int*)(&a) + 4) + i);
		fun1();
		cout << "\t地址:\t" << *((int*)*((int*)(&a) + 4) + i) << endl;
	}

	//[5]
	cout << "[5]B::ib=" << *(int*)((int*)(&a) + 5);
	cout << "\t地址: " << (int*)(&a) + 5;
	cout << endl;

	return 0;
}

运行结果

B1对象内存大小为：24
[0]B1::vptr     地址：00AFF740
  [0]B1::f1()   地址：  5706518
  [1]B1::Bf1()  地址：  5706038
[1]vbptr        地址：00AFF744
  [0]-4
  [1]12
[2]B1::ib1=100  地址：00AFF748
[3]值=0         地址：00AFF74C
[4]B::vptr      地址：00AFF74C
  [0]B1::f()    地址:   5706273
  [1]B::Bf()    地址:   5706828
[5]B::ib=1      地址: 00AFF754

这个结果与我们的C++对象模型图完全符合。这时我们可以来分析一下虚表指针的第二个条目值12的具体来源了，回忆上文讲到的：

第二、第三…个条目依次为该类的最左虚继承父类、次左虚继承父类…的内存地址相对于虚基类表指针的偏移值。

在我们的例子中，也就是B类实例内存地址相对于vbptr的偏移值，也即是：[4]-[1]的偏移值，结果即为12，从地址上也可以计算出来：00AFF74C-00AFF744结果的十进制数正是12。现在，我们对虚基类表的构成应该有了一个更好的理解。

6.3.虚拟菱形继承

如果我们有如下继承层次：

class B{...}
class B1: virtual public  B{...}
class B2: virtual public  B{...}
class D : public B1,public B2{...}

类图如下所示：
图 8

菱形虚拟继承下，最派生类D类的对象模型又有不同的构成了。在D类对象的内存构成上，有以下几点：

在D类对象内存中，基类出现的顺序是：先是B1（最左父类），然后是B2（次左父类），最后是B（虚祖父类）
D类对象的数据成员id放在B类前面，两部分数据依旧以0来分隔。
编译器没有为D类生成一个它自己的vptr，而是覆盖并扩展了最左父类的虚基类表，与简单继承的对象模型相同。
超类B的内容放到了D类对象内存布局的最后。

菱形虚拟继承下的C++对象模型为：
图 9

下面使用代码加以验证：

#include <iostream>
using namespace std;

class B
{
public:
	int ib;
public:
	B(int i = 1) :ib(i) {}
	virtual void f() { cout << "B::f()"; }
	virtual void Bf() { cout << "B::Bf()"; }
};

class B1 : virtual public B
{
public:
	int ib1;
public:
	B1(int i = 100) :ib1(i) {}
	virtual void f() { cout << "B1::f()"; }
	virtual void f1() { cout << "B1::f1()"; }
	virtual void Bf1() { cout << "B1::Bf1()"; }
};

class B2 : virtual public B
{
public:
	int ib2;
public:
	B2(int i = 1000) :ib2(i) {}
	virtual void f() { cout << "B2::f()"; }
	virtual void f2() { cout << "B2::f2()"; }
	virtual void Bf2() { cout << "B2::Bf2()"; }
};


class D : public B1, public B2
{
public:
	int id;
public:
	D(int i = 10000) :id(i) {}
	virtual void f() { cout << "D::f()"; }
	virtual void f1() { cout << "D::f1()"; }
	virtual void f2() { cout << "D::f2()"; }
	virtual void Df() { cout << "D::Df()"; }
};

typedef void(*Fun)(void);

int main()
{
	D d;
	cout << "D对象内存大小为：" << sizeof(d) << endl;

	//取得B1的虚函数表
	cout << "[0]B1::vptr";
	cout << "\t地址：" << (int*)(&d) << endl;

	//输出虚表B1::vptr中的函数
	for (int i = 0; i < 3; ++i)
	{
		cout << "  [" << i << "]";
		Fun fun1 = (Fun) * ((int*)*(int*)(&d) + i);
		fun1();
		cout << "\t地址：\t" << *((int*)*(int*)(&d) + i) << endl;
	}

	//[1]
	cout << "[1]B1::vbptr ";
	cout << "\t地址：" << (int*)(&d) + 1 << endl;  //虚表指针的地址
	//输出虚基类指针条目所指的内容
	for (int i = 0; i < 2; i++)
	{
		cout << "  [" << i << "]";
		cout << *(int*)((int*)*((int*)(&d) + 1) + i);
		cout << endl;
	}

	//[2]
	cout << "[2]B1::ib1=" << *(int*)((int*)(&d) + 2);
	cout << "\t地址：" << (int*)(&d) + 2;
	cout << endl;

	//[3]
	cout << "[3]B2::vptr";
	cout << "\t地址：" << (int*)(&d) + 3 << endl;

	//输出B2::vptr中的虚函数
	for (int i = 0; i < 2; ++i)
	{
		cout << "  [" << i << "]";
		Fun fun1 = (Fun) * ((int*)*((int*)(&d) + 3) + i);
		fun1();
		cout << "\t地址:\t" << *((int*)*((int*)(&d) + 3) + i) << endl;
	}

	//[4]
	cout << "[4]B2::vbptr ";
	cout << "\t地址：" << (int*)(&d) + 4 << endl;  //虚表指针的地址
	//输出虚基类指针条目所指的内容
	for (int i = 0; i < 2; i++)
	{
		cout << "  [" << i << "]";
		cout << *(int*)((int*)*((int*)(&d) + 4) + i);
		cout << endl;
	}

	//[5]
	cout << "[5]B2::ib2=" << *(int*)((int*)(&d) + 5);
	cout << "\t地址: " << (int*)(&d) + 5;
	cout << endl;

	//[6]
	cout << "[6]D::id=" << *(int*)((int*)(&d) + 6);
	cout << "\t地址: " << (int*)(&d) + 6;
	cout << endl;

	//[7]
	cout << "[7]值=" << *(int*)((int*)(&d) + 7);
	cout << "\t\t地址：" << (int*)(&d) + 7;
	cout << endl;

	//间接父类
	//[8]
	cout << "[8]B::vptr";
	cout << "\t地址：" << (int*)(&d) + 8 << endl;

	//输出B::vptr中的虚函数
	for (int i = 0; i < 2; ++i)
	{
		cout << "  [" << i << "]";
		Fun fun1 = (Fun) * ((int*)*((int*)(&d) + 8) + i);
		fun1();
		cout << "\t地址:\t" << *((int*)*((int*)(&d) + 8) + i) << endl;
	}

	//[9]
	cout << "[9]B::id=" << *(int*)((int*)(&d) + 9);
	cout << "\t地址: " << (int*)(&d) + 9;
	cout << endl;

	getchar();
}

查看运行结果

D对象内存大小为：40
[0]B1::vptr     地址：00EFF6D0
  [0]D::f1()    地址：  11801401
  [1]B1::Bf1()  地址：  11800866
  [2]D::Df()    地址：  11801021
[1]B1::vbptr    地址：00EFF6D4
  [0]-4
  [1]28
[2]B1::ib1=100  地址：00EFF6D8
[3]B2::vptr     地址：00EFF6DC
  [0]D::f2()    地址:   11801571
  [1]B2::Bf2()  地址:   11801366
[4]B2::vbptr    地址：00EFF6E0
  [0]-4
  [1]16
[5]B2::ib2=1000 地址: 00EFF6E4
[6]D::id=10000  地址: 00EFF6E8
[7]值=0         地址：00EFF6EC
[8]B::vptr      地址：00EFF6F0
  [0]D::f()     地址:   11801681
  [1]B::Bf()    地址:   11801651
[9]B::id=1      地址: 00EFF6F4