深入探索C++对象模型

hechengjin

深入探索C++对象模型（1）
http://www.cnblogs.com/tracylee/archive/2012/12/18/2822431.html

在实际生产中，遇到一个复杂的类，如果能看出这个类的内存模型结构，那么以后的操作基本就没有难度的；所以说，学会分析一个类的内存模型，是每一个C++程序员必须要会的知识。

（1）C++类封装和C中的结构体的区别

C++的类封装是在C语言中的结构体的基础上构建起来的，C结构体只允许存在数据，而不会存在对数据的操作。C++语言中延承C语言中的结构体，但增加的对数据的操作，即成员函数；类是对结构体的进一步封装，使某些数据成员对外不可见，称为私有成员。

类和结构体最大的区别就是：结构体成员均是public类型的。

那么，类和结构体的布局成本有没有区别呢？对于只有数据成员的类和结构体在内存的布局是相同的，没有增加成本。而members functions 虽然含在class的声明之内，却不出现在object之中。每一个non-inline member fuction 只会诞生一个函数实体，调用时链接至函数体。至于每一个"拥有零个或一个定义"的inline function则会在其每一个调用者（模块）身上产生一个函数实体。

在C++中，有两种class data members:static和nonstatic，以及三种class member functions:static、nonstatic和virtual。在C++对象模型中，非静态数据成员被配置在每一个class object之内，静态数据成员则被存在个别的class object之外，静态和非静态的成员函数也被放在个别的class object之外。

c++在布局及存取时间上主要的额外负担是由virtual引起。包括：

   1.virtual function 机制  用以支持一个有效率的"执行期绑定"  
   2.virtual base class 用以实现"多次出现在集成体系中的base class，
有一个单一而被共享的实体。
无论是含有虚函数还是虚拟继承，类都会产生一个虚函数表，同时每一个对象都会含有一个Vptr指针指向虚拟函数表。

虚拟函数的实现

1.每一个class产生一堆指向虚函数的指针，放在表格之中，这个表格被称为virtual table(vtbl)；

2.每一个class object被安插一个指针，指向相关的virtual table。这个指针通常被称为vptr。vptr的设定和重置都由每一个类的构造函数、析构函数和赋值操作符重载函数自动完成且一旦完成初始化不能修改。每一个类所关联的type_info object（主要用于RTTI）也经由virtual table被指出来，通常放在表格的第一个slot。

多重继承模型：

C++最初采用的继承模型时间基类对象中的数据成员直接存放在继承类对象内存中，包括基类对象的虚函数表和虚指针（貌似现在也是这样的模型），这样就可以对基类成员进行最有效率的存取，然而缺点是如果基类成员有任何的修改将会导致基类对象和继承类对象的重新编译。

有人提出一种间接存取模型：在继承类对象中放置一指针Bptr，该指针指向继承类的基类表，类似与虚函数表，基类表中每一项都指向继承类对象的基类对象。这样的好处是，基类对象的任何改变吗都不会影响到继承类对象的内存布局，缺点是导致对基类对象成员的存取效率低，随着继承深度的增加，间接性越强，效率越低。

因此又有人提出，在继承类对象中放置与基类相等数目的指针指向每个基类，这样存取时间就恒久不变了，但是这样无疑增加了继承类的内存开销。

目前使用的多重继承模型仍为第一种，继承类对象中含有所有基类对象数据成员和虚指针，同时继承基类的虚函数表共享为继承类的虚函数表。

虚拟继承模型：

虚拟继承保证继承类中只含有一个基类对象，继承类中会产生虚指针指向虚表中offset指向继承类中的基类对象。只有直接虚继承的继承类对象才会产生Vptr。

目前，关于虚拟继承的继承类的内存布局有三种模型：

1、原始模型：在每个继承类对象中设置指针，用以指向继承类中的基类对象。优点：通过指针能够保证继承类中只有一个基类对象，可以直接存取基类对象。缺点：若继承类有多个虚拟基类，则需要多个指针指向基类们，会消耗较多的内存。

2、有人提出像虚函数表一样，提供一个虚拟基类表virtual base class table，表中每个slot指向一个基类对象的地址。在继承类对象中，设置一个虚拟基类表指针指向基类表。优点：继承类减少了因虚拟基类指针而产生的开销，且继承类不会因为虚拟基类的增加而改变内存模型。缺点：存取基类对象数据成员会导致效率低下。

3、现在最常用的模型：扩充原Virtual table，在虚表负offset位置指向虚基类对象，因此，只要是虚继承就会产生虚指针和虚表。

虚拟多继承，采用“钻石”继承结构，其每个类的内存分布如下图：其中虚指针的位置可以在顶部或尾部。

上述内容是类对象内存模型的介绍：

（1）无虚函数和虚继承：nostatic数据成员存放在对象中，static数据成员存放在对象外属于整个类。nostatic和static函数成员均放在对象外。

（2）有虚函数和虚继承：virtual函数放在虚函数表中，通过虚指针进行查找调用。基类对象数据成员和虚指针均存放在继承类的对象中。

深入探索C++对象模型（2）http://www.cnblogs.com/tracylee/archive/2012/12/18/2824125.html

上一章讲过了关于类对象内存分布，对于nostatic数据将会放在对象内存空间中，static数据成员和nostatic、static函数成员将不会放在对象内存中，对于虚拟继承和含有虚函数的类来说，将会在对象内存中增加一个虚表指针，指向该类的虚表，其中虚表中将会存放虚函数的地址和虚拟基类的地址。一个类中只含有一个共享虚表（继承基类的虚表也是继承类的虚表，一般继承类的虚函数会存放在第一个基类的虚表中方便提取），对象中可以含有多个虚指针，继承至基类，除了直接虚拟继承的继承类才会产生新的vptr和虚表用于指示虚拟基类的位置。

下面是如何构建类对象，即构造函数的深入探索。

首先强调两个C++新手容易陷入的误区：

（1）编译器会为没有显示声明构造函数的类合成默认构造函数；-------------并不是所有的都合成默认构造函数，只有只有四种情况下才会合成，其他情况下不会合成。

（2）编译器合成出来的默认构造函数会为每个数据成员赋予默认值。------------编译器不负责对数据成员的赋值工作，并不是编译器所需的，而应该是程序员完成的工作。(除非其有默认构造函数的subobject和memeber在构造时会初始化）

那么，哪四种情况会导致编译器为类合成一个默认的构造函数呢？

（1）类成员存在默认构造函数的，在合成默认构造函数时必须调用该成员的默认构造函数或者是扩充到已有的默认构造函数中；

（2）所继承的基类存在默认构造函数的，编译器会合成默认构造函数，在构造函数中调用基类默认构造函数；

（3）含有虚函数的类，编译器会合成默认构造函数，主要是因为要初始化虚表指针；

（4）虚继承的类，编译器会合成默认构造函数，也是因为要初始化虚表指针，指向虚拟基类对象。

当已经显示定义了构造函数，即使不是默认的构造函数，编译器也不会为类合成默认构造函数。如果显示定义的构造函数没有完成一些默认构造的功能，编译器将会扩充显示定义的构造函数，调用能够调用的默认构造函数比如成员默认构造函数或基类默认构造函数。

----------------------------------------------------------------------------------------------------------------------------------------------------------

复制构造函数深度探索：

复制构造函数只要用于三个方面：用一个对象的内容构造出一个新对象；参数以值传递的形式传递时；以一个对象作为返回值时。在这三种情况下将会调用复制构造函数，有的情况下需要产生临时对象。

例如：string s=a；将不会产生临时对象，string s=string(a);将会产生临时对象t，然后在调用复制构造函数构造s；string s(a);也不会产生临时对象。

当参数和返回值以值传递的形式，一般情况下都会产生临时对象存储数据，当在编译器NRV优化（下面细讲）的情况下，返回值可能不要产生临时对象，而是直接操作，例如：

T operator+(T &a,T &b); Tc=a+b;

在编译器优化的情况下，operator +函数极有可能是这个样子的：

//编译器内部伪码

void operator +(T &a,T &b,T &c)

{

　　//直接对c进行操作，这种情况下不需要产生构造对象

}

复制构造的两种方式：bitwise和memeberwise，前者是单纯的位拷贝，后者则是以成员为单位进行递归拷贝（所谓递归拷贝就是当成员为一个类对象时将会按照该对象的成员进行拷贝知道结束）。另外，复制构造函数也会对数组的所有成员进行拷贝。

当类中没有显示定义的复制构造函数的时候，编译器会不会合成一个复制构造函数呢？要根据该类的复制构造形式而定，bitwise形式不会合成复制构造函数，memberwise形式会合成。

以下有四种情况会导致类不是bitwise形式，会在无显示定义复制构造函数的时候合成默认复制构造函数：

（1）类成员对象含所有显示复制构造函数（无论是编译器合成的还是自定义的，有时候为了实现NRV优化会自定义复制构造函数），编译器会为这样的类合成默认复制构造函数；

（2）类的基类对象含有复制构造函数，编译器会构造默认复制构造函数，构造的时候将会调用扩充基类复制构造函数；

（3）类中含有虚函数的，编译器将会构造默认复制构造函数，这样可以保证当基类对象被继承类对象初始化的时候，基类对象的vptr指向正确的虚函数表，而不能单纯的复制vptr那么容易，否则将会造成基类对象的vptr指向继承类的虚表了；

（4）虚拟继承的类，编译器将会构造默认复制构造函数，同样是当基类对象被子类对象初始化时，必须保证指向虚拟基类对象的指针被正确设置，因为虚拟基类对象在不同子类内存中的位置是不同的，在虚表中对应offset值是不同的，所以必须保证vptr所指向的虚表的正确性，因此编译器将会为虚拟继承的类合成默认复制构造函数。

---------------------------------------------------------------------------------------------------------------------------------------------

NRV编译器优化：前提是编译器提供该服务，且类中存在复制构造函数，无论是编译器合成的还是自定义的，否则优化无从谈起，因为trival复制构造函数就是最有效率的构造方法，有些类为了使用NRV优化甚至强行提供显示复制构造函数。

NRV优化主要用在返回值为对象的函数身上，主要方法是减少临时对象的数目来提高效率。

优化前：

X bar（）//将会产生临时对象存储返回的值

{

　　X xx;

　　//处理

　　return xx;

}

优化后：

void bar（X &_result)//这样在指定函数返回对象是将不会产生临时对象

{

　　X xx;

　　//处理xx

　　//调用复制构造函数

　　_result.X::X(xx);

　　return；

}

X yy=bar();相当于bar(yy);

但是，当bar（）单独使用的时候，仍然会产生一个临时对象存储结果，因为函数没有返回的对象。

而NRV优化又是在上述的基础上直接对_result上处理，不需要在函数内部产生一个xx对象，然后再调用复制构造函数，这样就减省了复制构造的消耗，但是会使用默认构造函数。

void bar（X &_result)//NRV优化

{

　　_result.X::X();

　　//对_result直接进行处理

　　return;

}

-------------------------------------------------------------------------------------------------------------------------------------------------

成员初始化表的使用：

有以下三种情况必须使用成员初始化表：

（1）调用基类构造函数或者基类复制构造函数

（2）类对象中的引用初始化

（3）类中const对象的初始化

其成员初始化既可以使用成员初始化列表，也可以使用普通的方式，但还是普通方式效率太低。

普通初始化方式：首先将成员默认构造，然后产生一个临时对象使用复制构造参数对象，最后使用赋值方式初始化；

而成员初始化列表则会在用户代码之前按照成员声明的顺序并按相应的方式进行初始化。

注意：

成员初始化列表中的顺序不决定初始化顺序，成员初始化顺序由成员声明的顺序而定；

成员初始化列表中的内容先于用户代码执行

hechengjin

深度探索C++对象模型（4）http://www.cnblogs.com/tracylee/archive/2012/12/20/2825562.html

类中函数的深度探索

类中包含的函数主要有三种：static成员函数、nostatic成员函数、virtual成员函数。

C++类中数据成员和成员函数的命名机制：

数据成员的命名：在每个数据成员命名的时候编译器将该成员所属的类名也添加上，用来标志这个成员的来源范围。这样，继承类就可以与子类用相同的名字命名其成员，这样就不会产生二义性和冲突，但是对外界而言，通过继承类对象访问该名字，只会获取继承类的数据成员，因为根据命名查找机制，两个名字属于不同的作用域，继承类中的成员覆盖了子类中的成员，想要调用必须显示调用子类成员或在继承类作用域中使用using。（函数名相同）

成员函数的命名：在同一个类中允许函数重载，重载的机制就是对函数名+参数名编码获得唯一的编码识别。

（1）static成员函数

　　首先，说明static成员函数的几条限制：1）static成员函数只能使用static数据成员；2）static成员函数不能设为const、virtual、inline函数，只能保持一份实例；3）static成员函数不使用this指针，因此不必需要通过对象来访问，虽然很多时候是这样使用的。

　　static成员函数在内存空间中只有一份实例，如果取函数的地址，得到的是真实的内存地址，其函数指针是与普通函数相同的函数指针，而不是指向成员函数的指针，例如

　　static int foo();       int (*p)()=&A::foo; 使用方法与普通函数指针相同。

　　因此，对于static成员函数的调用与调用非成员函数的效率是相同的。

（2）nostatic成员函数

　　虽然nostatic成员函数也是存放在对象外的内存空间中，且取其函数地址也是真实的内存地址，但是调用nostatic成员函数也需要通过对象，也就是说需要this指针，因为nostatic成员函数中可以直接使用类数据成员。

　　编译器将this指针作为参数传进nostatic成员函数中去，然后通过this指针访问数据成员。例如：

　　int foo();A a;a.foo();编译器将转化为foo(&a);

　　编译器将成员函数转化为了非成员函数，是的对成员函数的调用不会有异于非成员函数。

　　成员函数的指针的使用也必须通过对象调用，例如

　　int (A::*p)()=&A::foo;(a.*p)();相当于p(&a)调用，也可以由其继承类对象调用。

（3）virtual函数

　　虚拟成员函数地址存放在虚表中，而获得到虚表的访问权仍然需要通过对象的地址。

　　指向虚拟成员函数的指针获取到的虚拟成员函数的地址实际上是虚拟函数在虚表中slot编号，通过该编号可以获取到虚拟成员函数的地址，也正是因为获取得到的是编号而非真正的内存地址，才能实现多态机制。

　　1）单一继承

　　单一继承情况下，子类会继承父类的vptr指针和虚表，不会产生新的vptr，这时，子类中若存在不同与父类的虚拟函数，将会添加到虚表的尾部，子类若修改了父类中虚拟函数的定义，将会在虚表中相应的位置进行覆盖指向新的函数地址，也就是说，子类的虚表是在父类虚表的基础上扩展修改得到的。

　　2）多重继承

　　多重继承中牵扯到this指针调整的问题，也就是第二个及以后的父类地址的问题。C++中将继承类的虚函数写到第一个父类的虚表中，而第一个父类的虚表也就成为主虚表，其他的则成为次虚表。

　　在继承类中修改的虚函数将会覆盖所有的虚表中原虚函数，凡是继承类中存在的虚函数都会在主虚表中出现，对于没有修改的虚函数，其实际地址存放位置仍然在原父类的虚表中，调用的时候需要进行this指针调整。

　　如图，Derived a;a.mumble();的调用将会在主虚表中查到4号函数，然后将this指针调整到Base2位置，同多Base2 子对象调用mumble（）函数。

　　再例如，Base2 *p=new Derived; delete p;也会产生this指针的调整，必须调用正确的析构函数，this指针必须回到真个Derived对象的地址首部。

　　因此，对于多重继承主要是要考虑this指针的调整问题。

　　3）虚拟继承

　　虚拟继承的子类将会产生一个vptr和一个虚表来存储子类中虚拟函数和其子类对象的地址。

　　虚拟继承也需要进行this指针的调整，如同多重继承一样，但是this指针的调整更加复杂，建议不要在虚拟基类中定义nostatic成员，这样会使虚拟子类对象的offset值的确定变得过于复杂。（在不同子类中，虚拟子对象的offset是不相同的）。

hechengjin

深入探索C++对象模型（5）http://www.cnblogs.com/tracylee/archive/2012/12/21/2827174.html

虚拟继承下的对象构造：

由于虚拟基类对象在子类中只能保持一个实例，那么，子类构造的时候调用父类的构造函数的时候必须保证虚拟基类对象不能够重复构造。那么，C++规定虚拟基类对象的构造只能是最外层的子类进行构造，浅层次的子类将不会在进行构造，保证了虚拟基类对象的唯一性。

在虚拟继承体系下，子类的构造函数中必须做一个判断，设置一个标准位，用来判断虚拟基类对象是否已经构建，然后将该标志为传递给浅层次的子类，那么虚拟基类将不会再次构造。例如，编译器会为子类构造函数内部设置标志位

Point3D:oint3D(Point3D *this,bool _most_derived)

{

　　if(_most_derived!=fales)Point();//如果是最外层子类，构建虚拟基类对象

　　Point2D(false);

　　Vertex(false);//将false传入说明其父类不是最外层，将不会构建虚拟基类对象

}

继承体系下的对象构造：

必须首先将父类对象构造再构造子类对象内容。在子类构造函数中调用父类构造函数的方法可以是在成员初始化列表中显示调用构造函数，如果没有在成员初始化列表中进行构造，那么，编译器会在子类构造函数中扩充调用父类默认构造函数进行构造父类对象。

------------------------------------------------------------------------------------------------------------------------------

Vptr的深入探索

在前面我们知道，Vptr必须在构造对象的时候进行初始化设置，使它指向正确的类的虚表地址。那么，在什么时候进行vptr的设置呢？

C++标准规定构造函数中内容执行的顺序：

1、首先调用虚拟基类（若有首先调用虚拟基类构造函数）或基类们的构造函数，构建基类子对象；

2、设置该对象的vptr，使其指向适应的虚拟函数表；

3、执行成员初始化列表中的成员初始化；

4、执行用户程序内容。

因此，当遇到在构造函数或析构函数中调用虚函数问题的时候，答案就会很明确了。

在基类构造函数中调用虚函数，将不会使用多态机制，即不会调用其子类中的虚函数，因为在基类构造的时候，vptr的设置仍指向基类的虚表，而子类还未完成构造，vptr还未指向子类的虚表，因此，此时不会使用多态机制，仍然调用基类中的虚函数实例。而在构造函数中使用成员函数，成员函数中调用虚函数时也不适用多态机制。只有在非构造函数中调用虚函数时才会使用多态机制。

同理，析构函数中内容的顺序正好相反：

1、调用子类析构函数中实体，完成用户程序中内容的退栈；

2、析构释放子类中不同于基类的成员；

3、调整设置vptr，使其指向基类相对应的虚表；

4、完成基类的析构。

在基类析构函数中调用虚函数，也不会实现多态机制，因为子类已经析构完毕，vptr指向基类的虚表。

---------------------------------------------------------------------------------------------------------------------------------

赋值函数的深入探索：

未显示定义的赋值函数，编译器将视情况为类合成赋值函数，条件和合成复制构造函数的相同，只有当复制不适合bitmise的时候才会很成默认构造函数。

注意：复制构造函数时进行vptr的设定，而赋值函数不会进行vptr的设置，也就是说当以子类对象赋值给父类对象时，将不会改变父类对象的vptr指向，因为父类对象在构造的嘶吼已经进行了设定。

赋值函数需要进行自我识别：

加上一句，防止自我复制

if（this==&参数对象）return *this；

另外，赋值函数不能使用成员初始化列表，只有构造函数才能使用，这样就会导致，虚拟继承情况下，使用赋值函数复制对象时，会在被赋值的对象中出现多个虚拟基类对象的现象。

例如：

类A，B虚拟继承类base，C继承A和B，那么C的赋值函数就会这样写：

C& operator=（const C& c）

{

　　if(this==&c)return *this;

　　A:perator=(c);

　　B:perator=(c);//导致出现两份虚拟基类对象实例

　　//C自己的成员的复制

　　return *this;

}

建议：尽量不要使用赋值函数进行虚拟继承子类对象的复制。

hechengjin

深入探索C++对象模型（6）http://www.cnblogs.com/tracylee/archive/2012/12/21/2828157.html

对象数组的构造：

对象数据的构造一般有两种方式：静态和动态

（1）静态分配

　　以string类为例，string a[10];就是以静态形式构造数据，这样的数组的个数是确定的不能修改的。

　　像这样的数组怎么进行构造和析构呢？

　　编译器在构造数组的时候会生成一个使用默认构造函数的数组构造函数arr_new(char *p,sizeof(string),int num,构造函数地址，析构函数地址)；同样也会生成数组析构函数，形式类似。arr_del(char *p,sizeof(string),int num,析构函数地址);

　　若数组构造中间出现异常，该函数必须保证已构造的对象析构，然后释放内存。

　　如果数组对象不使用默认构造函数构造对象，必须显示构造，否则，未显示构造的对象将会使用上述函数进行默认构造。

（2）动态分配

　　使用new表达式进行操作，string *a=new string[10];

　　new表达式分为两个步骤：首先通过内存分配所用类型大小的空间，然后再该空间上调用相应的构造函数进行构造，上述语句使用默认构造函数。

　　delete 表达式则释放指针所指的内存（首先析构），大小按照指针类型的大小计算。与数组相对应的为delete[] a；

　　这样就可能造成一定错误：

　　当使用基类指针指向一个子类数组，则释放的时候将可能会产生错误

　　Base *p=new Derived[10];

　　delete[] p;

　　我们知道，new出来的数组是根据Derived对象大小*10的内存空间，而delete 则是根据指针类型的大小进行析构和释放内存的，且使用类似与静态分配时的arr_del函数进行析构释放内存，这样调用的就会是基类的析构函数和基类对象的大小。除了第一个元素，其他元素的析构都会错误的进行。

　　因此建议：不要使用基类指针指向一个子类数组。

　　上诉问题根据编译器而不同，微软的编译器可以支持使用基类指针释放子类数组，但是基于cfront的编译器g++将会出现错误，它会将指针类型的大小和析构函数传入它生成的arr_del函数进行析构释放，导致内存错误。