C++对象模型：第1章-C++对象模型

青旅半醒 2022-08-05 05:15 233阅读 0赞

与此文相关的文章：[  
][Link 1]

[多重继承和虚继承的内存布局][Link 1]

[C++对象模型][C]

[C++ 虚函数表解析][C_]

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

（1）虚函数机制；（2）虚基类

# C++类对象    #

这篇文章不错，本文几个图来自这里：[http://www.cnblogs.com/skynet/p/3343726.html][C]

在c语言中，“数据”和“处理数据的操作（函数）”是分开来声明的，也就是说，语言本身并没有支持“数据和函数”之间的关联性。在c++中，通过抽象数据类型（abstract data type，ADT），**在类中定义数据和函数，来实现数据和函数直接的绑定**。

概括来说，**在****C++类中有两种成员数据：static、nonstatic；三种成员函数：static、nonstatic、virtual**。

![Center][]

nonstatic data成员被配置于每一个类对象之内；static data成员被存放在个别类对象之外。

static 和 nonstatic 函数成员被放在个别类对象之外；

virtual函数则按照以下两个步骤支持：

a. 每个类产生一些（数量等于该类中的虚函数个数）虚函数的指针（指针指向的是虚函数的地址），放在虚函数表中；

b. 每个类对象会产生一个vptr指针，该指针指向虚函数表。vptr的设定和重置都是由每个类的构造函数、析构函数和拷贝赋值运算符自动完成。每个类含关联一个type\_info对象用以支持运行时类型识别（runtime type identification，RTT1），它是编译器生成的特殊类型信息，包括对象继承关系、对象本身的描述，RTT1是为多态而生成的信息，所以只有具有虚函数的对象才会生成。

# C++对象模型 #

关于C++对象模型主要的参考书就是Stanley B. Lippman所著的《深度探索C++对象模型》一书。然而就**虚函数表的布局问题，这是一个与编译器相关的问题**，因此，该书所提到的C++对象模型的布局问题**仅可作为参考**，而实际不同的编译器以及同一编译器的不同版本都可能有不同的实现方式。

例如下面要说的：（1）《深度探索C++对象模型》该书侯捷所译的版本第9页提到，虚函数表的第一项是存放type\_info参数的，但我实际测试的结果并不是这样：虚函数表的第一项是第一个声明的虚函数地址不是type\_info的地址。（2）这篇博文[C++对象模型][C]的验证说明其系统的编译器中：虚函数表的地址依次增大（例如第一个虚函数表的地址小于第二个虚函数表的地址），但是我的验证中虚函数表的地址却是依次递减的。（3）同样是上一条提到的博文中，其编译器下，虚函数表中每个表项（一个虚函数的地址）占四个字节，而我的g++（gcc 4.4.3）下是占四个字节，但是VS2010却不是这样。

我验证的编译器下，VS2010和gcc 4.4.3下与CSDN博主陈皓的文章[C++ 虚函数表解析][C_]结论一致。

## 没有派生类时的虚函数表 ##

![Center 1][]

#include <iostream>
    #include <string>
    #include <typeinfo>
    using namespace std;
    
    #include<iostream>
    
    using namespace std;
    
    class Base
    {
    public:
        virtual void test() {
            cout << "\t\t Base: virtual void test()" << endl;
        };
        int getIBase() const;
        static int instanceCount();
        virtual void print() const {
            cout << "\t\t Base: virtual void print() const" << endl;
        };
    protected:
        int iBase;
        static int count;
    };
    
    int main() {
        Base base;
        const type_info &a = typeid(base);
        cout << &a << "\t type_info base对象的地址" << endl;
        /*const type_info &b = typeid(base);
        cout << &b << "\t type_info base对象的地址"<< endl;*/
        cout << (int *)(&base) << "\t 虚函数表地址" << endl;
        typedef void (*Fun)();
        Fun fun = (Fun)*((int *)*(int *)(&base));
        cout  << &fun << "\t virtual void test()函数地址" <<endl;
        fun();
        Fun fun2 = (Fun)*(((int*)*(int*)(&base)) + 1);
        cout << &fun2 << "\t virtual void print() const函数地址" << endl;
        fun2();
    }

结果：

VS2010:

![Center 2][]

g++:

![Center 3][]

可以看出，虚函数表中表项地址一次递减。

结论：**虚函数按照其声明顺序放于表中。**

## **单继承，没有虚函数覆盖** ##

图参考文章：[http://www.cnblogs.com/skynet/p/3343726.html][C]

#include <iostream>
    #include <string>
    #include <typeinfo>
    using namespace std;
    
    #include<iostream>
    
    using namespace std;
    
    class Base
    {
    public:
    	virtual void test() {
    		cout << "\t\t Base: virtual void test()" << endl;
    	};
    	int getIBase() const;
    	static int instanceCount();
    	virtual void print() const {
    		cout << "\t\t Base: virtual void print() const" << endl;
    	};
    protected:
    	int iBase;
    	static int count;
    };
    
    class Drived: public Base {
    	virtual void test_drived( ) {
    		cout << "\t\t Derived：in drived" << endl;
    	}
    };
    int main() {
    	Drived d;
    	const type_info &a = typeid(d);
    	cout << &a << "\t type_info base对象的地址" << endl;
    	/*const type_info &b = typeid(base);
    	cout << &b << "\t type_info base对象的地址"<< endl;*/
    	cout << (int *)(&d) << "\t 虚函数表地址" << endl;
    	typedef void (*Fun)();
    	Fun fun = (Fun)*((int *)*(int *)(&d));
    	cout  << &fun << "\t virtual void test()函数地址" <<endl;
    	fun();
    	Fun fun2 = (Fun)*(((int*)*(int*)(&d)) + 1);
    	cout << &fun2 << "\t virtual void print() const函数地址" << endl;
    	fun2();
    	Fun fun3 = (Fun)*(((int*)*(int*)(&d)) + 2);
    	cout << &fun3 << "\t virtual void print() const函数地址" << endl;
    	fun3();
    }

结论：

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

**2）父类的虚函数在子类的虚函数前面。**

## 单继承：有函数覆盖 ##

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

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

## 多继承：无函数覆盖 ##

**1） 每个父类都有自己的虚表。**

**2） 子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）**

## 多继承：有函数覆盖 ##

**1)每个基类都有自己的虚表。**

**2)子类的成员函数被放到了第一个基类的表中。**

**3)内存布局中，其父类布局依次按声明顺序排列。**

**4) 如果子类重写了基类的虚函数，例如重写了基类的虚函数print()，那么，每个基类的虚表中的print()函数都被覆盖成了子类的print()。这样做就是为了解决不同的基类类型的指针指向同一个子类实例，而能够调用到实际的函数。**

[Link 1]: http://blog.csdn.net/u013074465/article/details/46390731
[C]: http://www.cnblogs.com/skynet/p/3343726.html
[C_]: http://blog.csdn.net/haoel/article/details/1948051
[Center]: /images/20220805/0427bd4da0d6460bba32eefb94c35fad.png
[Center 1]: /images/20220805/4bd36643a6684a73966a1fe214053d28.png
[Center 2]: /images/20220805/f2fc057622dd4ea1af44f15db572c19c.png
[Center 3]: /images/20220805/d79fa546047b461e8d473eab6e07d077.png