C++类对象所占内存空间大小分析

前言

类占内存空间是只类实例化后占用内存空间的大小，类本身是不会占内存空间的。用 sizeof 计算类的大小时，实际上是计算该类实例化后对象的大小。空类占用1字节原因：C++要求每个实例在内存中都有一个唯一地址，为了达到这个目的，编译器会给空类隐含添加1字节，保证空类实例化后在内存中得到的地址是独一无二的。

在C++里空类占的存储空间是0吗？类的成员函数占存储空间吗？类的虚成员函数占存储空间吗？如果对这几个问题的回答不是很确定的话，此篇内容可供参考。

1.空类占用1个字节的存储空间

#include <iostream>
using namespace std;

class A {

};

int main() {
	cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;
	// 定义两个对象a1,a2
	A a1;
	A a2;
	cout << "由类A实例化后的对象a1的地址：" << &a1 << endl;
	cout << "由类A实例化后的对象a2的地址：" << &a2 << endl;
	
	system("pause");
	return 0;
}

输出结果： （ 每次运行程序时系统为对象 a1、a2 分配的地址不唯一）

**原因：**类中没有任何成员变量，占用的存储大小本该为0，但是如果是0，类实例化出的对象就不会在内存上占用空间，没有地址，也就无法区分这些对象。为了解决这个问题，编译器会给空类隐含加一个字节，保证用此类定义的对象都有一个独一无二的地址。

2.类中的普通变量占用存储空间

#include <iostream>
using namespace std;

class A {
	int a; // int类型变量a
	char p; // char类型变量p
};

int main() {
	cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;
	system("pause");
	return 0;
}

输出结果：

记得对齐的问题，这点和 struct 的对齐原则很像！int 占 4 字节，char 占 1 字节，补齐 3 字节。因此类 A 占8字节！

3.类的成员函数（非虚函数）不占用存储空间

在1的基础上增加类的成员函数做测试：

#include <iostream>
using namespace std;
 
class A {
public:
        A(){} // 构造函数
        ~A(){} // 析构函数
        int func1(){ return 0;} // 普通成员函数
        int func2(){ return 0;} // 普通成员函数
};
 
 
int main(){
  cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;
 
  return 0;
}

输出结果：

原因： 成员函数（包括构造和析构函数）编译后存放在代码区，不占用类的存储空间。

4.类的静态成员变量不占用存储空间

在3的基础上定义一个静态成员变量做测试：

#include <iostream>
using namespace std;

class A {
public:
	A() {} // 构造函数
	~A(){} // 析构函数
	int func1() { return 0; } // 普通成员函数
	int func2() { return 0; } // 普通成员函数
	
private:
	static int num; // 类的静态成员变量
};

int main() {
	cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;
	
	system("pause");
	return 0;
}

输出结果：

**原因：**类里的静态成员变量在全局数据区中分配空间，不占用类的存储空间，全局只有一份，不会随着类的实例化存储在每个对象里。

5.类中的虚函数占用存储空间，但所占的空间不会随着虚函数的个数增长

在4的基础上定义3个虚成员函数做测试：

#include <iostream>
using namespace std;

class A {
public:
	A() {} // 构造函数
	~A(){} // 析构函数
	int func1() { return 0; } // 普通成员函数
	int func2() { return 0; } // 普通成员函数

	// 3个虚函数
	virtual int func3() { return 0; }
	virtual int func4() { return 0; }
	virtual int func5() { return 0; }
	virtual int func6() { return 0; }
private:
	static int num; // 类的静态成员变量
};

int main() {
	cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;
	
	system("pause");
	return 0;
}

输出结果：

(1) x86<32位> 情况下：

(2)x64<64位> 情况下：

**原因：**C++ 类中有虚函数的时候有一个指向虚函数的指针，在 32 位系统分配指针大小为 4 字节，而在 64 位系统分配指针大小为 8 字节。无论多少个虚函数，只有这一个指针，4 字节（32位系统）或者8字节（64位系统）。注意一般的函数是没有这个指针的，而且也不占类的内存。

6.继承 --- 子类所占空间

#include<iostream>
class CBase // 基类
{
public:
	CBase(void); // 构造函数不占空间
	virtual ~CBase(void); // 虚析构函数占空间，所占空间根据系统位数而定

private:
	int  a; // 普通变量占空间（4字节）
	char* p; // 指针类型变量占空间，根据系统位数而定
};

class CChild : public CBase // 子类CChild继承Cbase
{
public:
	CChild(void); // 不占空间
	~CChild(void); // 不占空间

	virtual void test();// 父类子类共享一个虚函数指针

private:
	int b;
};

int main() {
	char* str;
	std::cout << sizeof(str) << std::endl;
	std::cout << sizeof(CBase) << std::endl;
	std::cout << sizeof(CChild) << std::endl;
}

/*
32位系统下：
4 // 指针类型变量占4字节
12 // 虚析构函数指针占4字节+int a变量占4个字节+char* p占4个字节
16 // int类型变量b占4个字节+基类所占的12个字节
   // virtual void test();此时不占空间，原因是：父类子类共享一个虚函数指针
*/

/*
64位系统下：
8 // 指针类型变量占8字节
24 // 虚析构函数指针占8字节+(int a变量占4个字节+对齐另需4字节)+(char* p占4个字节+对齐另需4字节)
32 // (int类型变量b占4个字节+对齐另需4个字节)+基类所占的24个字节
*/

可见子类的大小是本身成员变量的大小加上父类的大小。其中有一部分是虚函数表的原因，父类子类共享一个虚函数指针。

7.空类与多重继承的空类占用内存空间

#include <iostream>

using namespace std;

class A {};

class A2 {};

class B : public A {};

class C : public A, public A2 {};

class D : public virtual B {}; // 虚继承


int main()
{
    cout << sizeof(A) << endl;
    cout << sizeof(B) << endl;
    cout << sizeof(C) << endl;
    cout << sizeof(D) << endl;

    return 0;

}

// 32位系统输出：
/*
1
1
1
4
*/

// 64位系统输出：
/*
1
1
1
8
*/

空类所占内存空间为1；单一继承或多重继承空类的空类所占空间还是1；但虚继承涉及虚指针，指针大小为4（32位系统），故虚继承后空类所占空间为4（32位系统）。

8.单一继承或多重继承时类占用内存空间

#include <iostream>

using namespace std;

class A {};

class A1 {};

class B : public A {
    int b;
};

class C : public A, public A1 {
    int c;
};



int main()
{
    cout << sizeof(A) << endl;
    cout << sizeof(B) << endl;
    cout << sizeof(C) << endl;
    return 0;

}

// 32位系统输出：
/*
1
4
8
*/

// 64位系统输出：
/*
1
4
8
*/

9.共有继承

#include <iostream>

class A {
};

class A1 : public A {
};

class B : public A{
	virtual void fun() = 0; // 定义虚函数
};

// 共有继承，共用虚函数指针，没有虚基指针
class C : public B{
};

class D : public A, public B{
};

int main()
{
	std::cout << "sizeof(A):" << sizeof(A) << std::endl;
	std::cout << "sizeof(A1):" << sizeof(A1) << std::endl;
	std::cout << "sizeof(B):" << sizeof(B) << std::endl; 
	std::cout << "sizeof(C):" << sizeof(C) << std::endl; 
	std::cout << "sizeof(D):" << sizeof(D) << std::endl; 

	return 0;
}

/*
32位系统下输出：
sizeof(A):1 // 空类A(1)
sizeof(A1):1 // 空类A(0) + A1(1)
sizeof(B):4 // 空类A(0) + 虚函数指针(4)
sizeof(C):4 // 与B共用虚函数指针(4)
sizeof(D):8 // A(1+3<对齐>) + 与B共用虚函数指针(4)
*/

/*
64位系统下输出：
sizeof(A):1 // 空类A(1)
sizeof(A1):1 // 空类A(0) + A1(1)
sizeof(B):8 // 空类A(0) + 虚函数指针(8)
sizeof(C):8 // 与B共用虚函数指针(8)
sizeof(D):16 // A(1+7<对齐>) + 与B共用虚函数指针(8)
*/

共有继承，共用虚函数指针，没有虚基指针。

10.虚继承

#include<iostream>

/*
虚继承与继承的区别：
1.多了一个虚基指针
2.虚基类位于派生类存储空间的最末尾
3.不会共用虚函数指针
*/

class A
{
	char a[3];
public:
	virtual void fun1() {};
};

// 测试一：单个虚继承，不带虚函数
class B : public virtual A
{
	char b[3];
};

// 测试二：单个虚继承，带自己的虚函数
class C : public virtual A
{
	char c[3];
public:
	virtual void fun2() {};
};

// 测试三：双重继承
class D : public virtual C
{
	char d[3];
public:
	virtual void fun3() {};
};

int main()
{
	std::cout << sizeof(A) << std::endl; 
	std::cout << sizeof(B) << std::endl; 
	std::cout << sizeof(C) << std::endl; 
	std::cout << sizeof(D) << std::endl; 
	return 0;
}

/*
32位系统输出：
8 // 8【虚函数指针占4个字节；char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加1个】
16 // 8(A) + 8(B)【8 == (3+1)+虚基指针】
20 // 8(A) + 12(C)【12 == (3+1)+自己的虚函数指针+虚基指针】
32 // (char d[3]占3个字节+对齐另需1个字节)+类D自己的虚函数指针(4个字节)+虚基指针(4个字节)
      +(char c[3]占3个字节+对齐另需1个字节)+类C自己的虚函数指针(4个字节)+虚基指针(4个字节)
	  +(char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加1个字节) + 类A自己的虚函数指针占4个字节

*/

/*
64位系统输出：
16 // 【虚函数指针占8个字节；char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加5个】
32 // 16(A) + 16【16 == (char b[3]占3个字节+对齐另需5个字节)+虚基指针(8个字节)】
40 // 16(A) + 24【24 == <(char c[3]占3个字节+对齐另需5个字节)+自己的虚函数指针(8个字节)+虚基指针(8个字节)>】
64 // (char d[3]占3个字节+对齐另需5个字节)+类D自己的虚函数指针(8个字节)+虚基指针(8个字节)
      +(char c[3]占3个字节+对齐另需5个字节)+类C自己的虚函数指针(8个字节)+虚基指针(8个字节)
	  +(char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加5个字节) + 类A自己的虚函数指针占8个字节
*/

注意，虚继承的时候 A B C D 四个类不仅不会共享虚基类指针，也不会共享虚函数指针，要和普通继承区分开来。

具体分析如下：

 class A size(8):
      +---
 0    | {vfptr}
 4    | a
      | <alignment member> (size=1)
 8    +---
 
 class B size(16):
      +---
 0    | {vfptr}
 4    | {vbptr}
 8    | b
      | <alignment member> (size=1)
      +---
      +--- (virtual base A)
12    | a
      | <alignment member> (size=1)
16    +---
    
 class C size(20):
      +---
 0    | {vfptr}
 4    | {vbptr}
 8    | b
      | <alignment member> (size=1)
      +---
      +--- (virtual base A)
12    | {vfptr}
16    | a
      | <alignment member> (size=1)
20    +---    
 
 class D size(32):
      +---
 0    | {vfptr}
 4    | {vbptr}
 8    | c
      | <alignment member> (size=1)
      +---
      +--- (virtual base A)
12    | {vfptr}
16    | a
      | <alignment member> (size=1)
      +---
      +--- (virtual base B)
20    | {vfptr}
24    | {vbptr}
28    | b
      | <alignment member> (size=1)
32    +---

• 虚表（vftable）
• 虚函数指针（vfptr）
• 虚基指针（vbptr）

11.总结

空的类是会占用内存空间的，而且大小是 1，原因是 C++ 要求每个实例（对象）在内存中都有独一无二的地址。

（一）类内部的成员变量：

• 普通的变量：是要占用内存的，但是要注意对齐原则（这点和 struct 类型很相似）。
• static 修饰的静态变量：不占用内容，原因是编译器将其放在全局变量区。

（二）类内部的成员函数：

• 普通函数：不占用内存。
• 虚函数：有一个指向虚函数的指针，要占用 4 个字节或 8 个字节（根据系统位数来定），用来指定虚函数的虚拟函数表的入口地址。所以一个类的虚函数所占用的地址是不变的，和虚函数的个数是没有关系的。

（三）虚继承与继承的区别：

• 多了一个虚基指针。
• 虚基类位于派生类存储空间的最末尾。
• 不会共用虚函数指针。

参考自：

C++类对象到底占多大存储空间呢_类的成员函数占用空间吗_haowunanhai的博客-CSDN博客
https://www.cnblogs.com/linuxAndMcu/p/10388330.html

C++中的类所占内存空间总结

c++虚表（vftable）、虚函数指针（vfptr）、虚基指针（vbptr）的测试结果

https://www.cnblogs.com/aqing1987/p/4210773.html