C++类对象内存分布调试结果整理

1、没有数据成员的类

代码：

class Base {

};


int main()
{
	Base cobj;
	std::cout << "Base size is : " << sizeof(Base) << std::endl;

	return 0;
}

调试：

结论：
对于没有成员变量的类，编译器会强行(隐式)地插入一个字节，保证此种特殊类在实例化时具有指针地址空间。

2、只有数据成员的类

代码：

class Base {

private:
	int m_base_1;
	int m_base_2;
};


int main()
{
	Base cobj;
	std::cout << "Base size is : " << sizeof(Base) << std::endl;

	return 0;
}

调试：

结论：
1、成员变量是按照定义的顺序来保存的；
2、类对象的指针地址就是第一个数据成员变量的起始地址；
2、类对象的大小就是所有成员变量大小之和。

3、只有成员变量和普通函数的类

代码：

class Base {

public:
	int baseFun() {};
private:
	int m_base_1;
	int m_base_2;
};


int main()
{
	Base cobj;
	std::cout << "Base size is : " << sizeof(Base) << std::endl;

	return 0;
}

调试：

结论：
1、此处和前面的结果是一样的；
2、非虚成员函数可以被看作是类作用域下的全局函数，不存在实例分配的空间里，由该类所有实例所共享，它们的地址编译期就已确定，实例调用成员函数时，编译器向成员函数传入this指针完成和实例的匹配；
3、类的静态成员函数也是类作用域下的全局函数，不存在实例分配的空间里，但它属于整个类，不属于类的实例，它不需要实例化也能调用，而非虚成员函数必须实例化才能调用。

4、拥有虚函数的类

代码：

class Base {

public:
	int baseFun() { return 0; }
	virtual void vfBase1() {};
	//virtual void vfBase2() {};

public:
	int m_base_1;
	int m_base_2;
};


int main()
{
	Base cobj1;
	std::cout << "cobj1 size is : " << sizeof(Base) << std::endl;
	std::cout << "_vftable offset size is : " << offsetof(Base, m_base_1) << std::endl;

	Base cobj2;
	std::cout << "cobj2 size is : " << sizeof(Base) << std::endl;

	return 0;
}

调试：

结论：
1、含有虚函数的类对象里会有一个指针，叫虚函数表指针__vfptr，指向虚函数表，虚函数表是一个指针数组，其中的每一个元素都是一个函数指针，指向对应的虚函数；
2、类所拥有的虚函数的数量， 并不会影响到类对象的大小以及布局情况，只是在虚函数表中添加一项函数指针；
3、同一个类的不同对象共用同一份虚函数表，它们都通过虚函数表指针__vfptr(定义为void**类型)指向该虚函数表；
4、虚函数表是编译器在编译时期创建好的, 只存在一份，同一个类的不同对象共用同这份虚函数表，虚函数表保存在.rodata（只读数据段）；
5、定义类对象时, 编译器自动将类对象的__vfptr指向这个虚函数表。

5、单继承且本身不存在虚函数的派生类的内存布局

代码：

class Base {

public:
	int baseFun() { return 0; }
	virtual void vfBase1() {};
	virtual void vfBase2() {};

public:
	int m_base_1;
	int m_base_2;
};

class DerivedBase : public Base
{
public:
	int m_derive_1;
	int m_derive_2;

private:

};

int main()
{
	DerivedBase cobj;
	std::cout << "cobj size is : " << sizeof(DerivedBase) << std::endl;

	return 0;
}

调试：

结论：
1、继承的类各个数据成员内存分布是连续的，
2、继承类内存总体上分为两个部分，一部分是基类内存，包括虚函数指针表和基类成员变量，另一部分是继承类部分，包括继承类成员变量；
3、继承类所有的变量的内存地址分配都是连续的，并且是按照基类和继承类各个成员变量的申明顺序进行的内存分配。

6、覆盖的基类虚函数的单继承派生类的内存布局

代码：

class Base {

public:
	int baseFun() { return 0; }
	virtual void vfBase1() {};
	virtual void vfBase2() {};

public:
	int m_base_1;
	int m_base_2;
};

class DerivedBase : public Base
{
public:
	int m_derive_1;
	int m_derive_2;
	virtual void vfBase2() {};
private:

};

int main()
{
	DerivedBase cobj;
	std::cout << "cobj size is : " << sizeof(DerivedBase) << std::endl;

	return 0;
}

调试：

结论：
·1、当派生类覆盖了基类时虚函数时，会引起虚函数指针表中内容的变化，如下图所示：

2、由于虚函数表发生了变化，所以指向派生类对象的基类指针在调用vfBase2函数时，将会调用派生类的vfBase2函数。

7、基类有纯虚函数的单继承派生类的内存布局

代码：

class Base {

public:
	int baseFun() { return 0; }
	virtual void vfBase1() = 0;
	virtual void vfBase2() = 0;

public:
	int m_base_1;
	int m_base_2;
};

class DerivedBase : public Base
{
public:
	int m_derive_1;
	int m_derive_2;
public:
	virtual void vfBase1() {};
	virtual void vfBase2() {};
private:

};

int main()
{
	DerivedBase cobj;
	std::cout << "cobj size is : " << sizeof(DerivedBase) << std::endl;

	return 0;
}

调试：

结论：
1、有纯虚函数的基类不允许被实例化；
2、派生类如果没有全部实现基类的纯虚函数，也不允许被实例化；
3、纯虚函数指针表在基类实现，函数地址全部指向派生类实现地址，如下图所示：

8、关于虚函数使用需要注意的地方

1. 只需要在虚函数的声明处加上 virtual 关键字，函数定义处可以加也可以不加。
2. 为了方便，可以只将基类中的函数声明为虚函数，这样所有派生类中具有遮蔽关系的同名函数都将自动成为虚函数；
3. 当在基类中定义了虚函数时，如果派生类没有定义新的函数来遮蔽此函数，那么将使用基类的虚函数；
4. 只有派生类的虚函数覆盖基类的虚函数（函数原型相同）才能构成多态（通过基类指针访问派生类函数）。例如基类虚函数的原型为virtual void func();，派生类虚函数的原型为virtual void func(int);，那么当基类指针 p 指向派生类对象时，语句p -> func(100);将会出错，而语句p -> func()将调用基类的函数；
5. 构造函数不能是虚函数。对于基类的构造函数，它仅仅是在派生类构造函数中被调用，这种机制不同于继承。也就是说，派生类不继承基类的构造函数，将构造函数声明为虚函数没有什么意义；
6. 析构函数可以声明为虚函数，而且有时候必须要声明为虚函数。

9、多态构成的必要条件

1）必须存在继承关系；
2）继承关系中必须有同名的虚函数，并且它们是覆盖关系（函数原型相同）。
3）存在基类的指针，通过该指针调用虚函数。
例如以下代码：

#include <iostream>

using namespace std;

//基类Base
class Base {
public:
	virtual void func();
	virtual void func(int);
};
void Base::func() {
	cout << "void Base::func()" << endl;
}
void Base::func(int n) {
	cout << "void Base::func(int)" << endl;
}

//派生类Derived
class Derived : public Base {
public:
	void func();
	void func(char *);
};
void Derived::func() {
	cout << "void Derived::func()" << endl;
}
void Derived::func(char *str) {
	cout << "void Derived::func(char *)" << endl;
}

int main() {
	Base *p = new Derived();
	p->func();  //输出void Derived::func()
	p->func(10);  //输出void Base::func(int)
	p->func("http://c.biancheng.net");  //compile error

	return 0;
}

将上述代码这样修改也是不对的：

int main() {
	Derived *p = new Derived();
	p->func();  //输出void Derived::func()
	p->func(10);  //compile error
	p->func("http://c.biancheng.net");  //输出void Derived::func(char *)

	return 0;
}

综合以上，基类和派生类能够公用的函数只有void fun()一个函数，其他两个都不可以。