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

类所占内存的大小是由成员变量(静态变量除外)决定的,成员函数(这是笼统的说,后面会细说)是不计算在内的。

示例如下:

(一)

class CBase 
{ 
}; 

sizeof(CBase)=1;

为什么空的类什么都没有是 1 呢?

c++要求每个实例在内存中都有独一无二的地址。空类也会被实例化,所以编译器会给空类隐含的添加一个字节,这样空类实例化之后就有了独一无二的地址了。所以空类的 sizeof 为 1。

(二)

class CBase 
{ 
	int a; 
	char p; 
}; 

sizeof(CBase)=8;

记得对齐的问题,这点和 struct 的对齐原则很像!int 占 4 字节,char 占一字节,补齐 3 字节。

(三)

class CBase 
{ 
public: 
	CBase(void); 
	virtual ~CBase(void); 
    
private: 
	int  a; 
	char *p; 
}; 

sizeof(CBase)=12

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

(四)

class CChild : public CBase 
{ 
public: 
	CChild(void); 
	~CChild(void); 

virtual void test();
	private: 
	int b; 
}; 

sizeof(CChild)=16;

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

(五)

#include <iostream>

class 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(B)" << sizeof(B) << std::endl; // 空类A(0) + 虚函数指针(4)
	std::cout << "sizeof(C)" << sizeof(C) << std::endl; // 与B共用虚函数指针(4)
	std::cout << "sizeof(D)" << sizeof(D) << std::endl; // A(1+3) + 与B共用虚函数指针(4)

	return 0;
}

/*
输出:
sizeof(A)1
sizeof(B)4
sizeof(C)4
sizeof(D)8
*/

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

(六)

#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; // 8
	std::cout << sizeof(B) << std::endl; // 8(A) + 8(B)【8 == (3+1)+虚基指针】
	std::cout << sizeof(C) << std::endl; // 8(A) + 12(C)【12 == (3+1)+自己的虚函数指针+虚基指针】
	std::cout << sizeof(D) << std::endl; // 8(A) + 12(C) + 12(D)
	return 0;
}

/*
输出:
8
16
20
32
*/

注意,虚继承的时候 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

总结

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

(一)类内部的成员变量:

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

(二)类内部的成员函数:

  • 普通函数:不占用内存。
  • 虚函数:有一个指向虚函数的指针,要占用 4 个字节,用来指定虚函数的虚拟函数表的入口地址。所以一个类的虚函数所占用的地址是不变的,和虚函数的个数是没有关系的。

(三)虚继承与继承的区别:

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

参考:

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

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

原文链接: https://www.cnblogs.com/linuxAndMcu/p/10388330.html

欢迎关注

微信关注下方公众号,第一时间获取干货硬货;公众号内回复【pdf】免费获取数百本计算机经典书籍

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

原创文章受到原创版权保护。转载请注明出处:https://www.ccppcoding.com/archives/290009

非原创文章文中已经注明原地址,如有侵权,联系删除

关注公众号【高性能架构探索】,第一时间获取最新文章

转载文章受原作者版权保护。转载请注明原作者出处!

(0)
上一篇 2023年2月15日 下午12:28
下一篇 2023年2月15日 下午12:29

相关推荐