关于C++中类的占用内存大小

本是古典何须时尚 2022-08-26 15:12 206阅读 0赞

所有的函数都是存放在代码区的,不管是全局函数，还是成员函数。sizeof访问的程序的数据段。

1. 类的大小为类的非静态成员数据的类型大小之和，也 就是说静态成员数据不作考虑。

2. 普通成员函数与sizeof无关。

3. 静态成员并不属于某个对象，sizeof取的是对象大小。

4. 虚函数由于要维护在虚函数表，所以要占据一个指针大小，也就是4字节。

5. 空类的sizeof为1。因为一个空类也要实例化，所谓类的实例化就是在内存中分配一块地址，每个实例在内存中都有独一无二的地址。同样空类也会被实例化，所以编译器会给空类隐含 的添加一个字节，这样空类实例化之后就有了独一无二的地址了。所以空类的sizeof为1。

6. Sizeof(类名)是在编译时就计算了的，一个类定义了，它所占的内存编译器就已经知道了，这时只是得到它占用的大小，并没有分配内存操作 。也可以这样想：编译器肯定知道大小了，这与分配内存空间无关，知道大小了，以后实例化了才能知道要分配多大。

类是抽象的，是不占有内存的，可是如果类生成实例那么将会在内存中分配一块内存来存储这个类。

7. 类的总大小也遵守类似class字节对齐的，调整规则。

8. 静态成员函数与一般成员函数的唯一区别就是没有this指针，因此不能访问非静态数据成员。

以下转自：[http://blog.csdn.net/chenyiming\_1990/article/details/10308507][http_blog.csdn.net_chenyiming_1990_article_details_10308507]

关于结构体和C++类的内存地址问题  
C++类是由结构体发展得来的，所以他们的成员变量（C语言的结构体只有成员变量）的内存分配机制是一样的。下面我们以类来说明问题，如果类的问题通了，结构体也也就没问题啦。 类分为成员变量和成员函数，我们先来讨论成员变量。 一个类对象的地址就是类所包含的这一片内存空间的首地址，这个首地址也就对应具体某一个成员变量的地址。（在定义类对象的同时这些成员变量也就被定义了）我们来以一段代码说明问题：

**\[cpp\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **class** K  
2.  \{  
3.     **public**:  
4.        K()\{k = 12;\}  
5.        ~K()\{\}  
6.        **int** k;  
7.  \};   
8.    
9.  K kTemp;  
10. printf("%d--%d\\n",&kTemp,&kTemp.k);  
11. printf("%d--%d\\n",**sizeof**(K),**sizeof**(kTemp.k));  
12. **int** \*i = (**int**\*)(&kTemp);  
13. **int** w = \*i;  
14. printf("%d\\n",w);

运行上面的代码，结果如下：  
1310588--1310588  
4--4  
12  
很明显,类的内存大小和其唯一的成员变量的内存大小是一致的。内存地址也是一致的。他们甚至可以相互转换。换成结构体结果也是一样。。 那么成员函数又如何？ 上面得代码就好像类没有任何成员函数一样，根本说明不了问题。 呵呵 ，所有的函数都是存放在代码区的,不管是全局函数，还是成员函数 。要是成员函数占用类的对象空间,那么将是多么可怕的事情:定义一次类对象就有成员函数占用一段空间。 我们再来补充一下静态成员函数的存放问题吧： 静态成员函数与一般成员函数的唯一区别就是没有this指针 ，因此不能访问非静态数据成员，就像我前面提到的，所有函数都存放在代码区，静态函数也不例外。所有有人一看到 static 这个单词就主观的认为是存放在全局数据区，那是不对的  
  
c++是一种面向对象的编程语言，它向下保持了对c的兼容，同时也允许程序员能够自由的操控内存，虽然会带来一些问题，但这不是我们要探讨的问题，略过不表。类是对某种对象的定义，包含变量和方法，也可以理解为现实生活中一类具有共同特征的事务的抽象，他是面向对象语言的基础。所以类是不占有内存的，可是如果类生成实例那么将会在内存中分配一块内存来存储这个类。  
类的实例在内存中是如何分配内存的，有什么需要我们注意的，下面将慢慢到来。

比如下面一个类：  
class A  
\{\};  
从形式上看，它似乎什么有没有，事实上它不止隐含了一个构造函数和一个析构函数，还有一些操作符重载函数，比如“=”。如果类A被实例话，如A a;在内存会占据多大的空间呢？有人可能会说4，也有人会说0，还有人会说1，说1的就对了，为什么会是1呢？原因有很多，如果我们定义一个数组A b\[10\];如果上面是0，这样的局面将会很尴尬，所以A这样一个空类，编译器会给它一个字节来填充。

增加一个变量，（字节对齐默认都是4）

**\[cpp\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **class** A  
2.  \{  
3.       **public**：  
4.       **int** i;  
5.  \}

类A的实例将占据4个字节的内存，sizeof(A) = 4  
变量i 的初值被编译器指定位0xcdcdcdcd。

再增加一个变量，

**\[cpp\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **class** A  
2.  \{  
3.     **public**：  
4.        **int** i;  
5.        **int** l;  
6.  \}

此时按照变量生命的先后顺序，i被放在低地址上，l紧随其后。  
实例占用8个字节，sizeof(A) = 4\*2 = 8

如果类里面含有函数：  
class A  
\{  
public:  
int i;  
int l;  
int add(int x,int y)\{return (x+y);\}  
\};  
有些人可能会说类的大小是12，事实上sizeof(A) = 8；  
为什么会这样，这是因为sizeof访问的程序的数据段，而函数地址则被保存在代码段内，所以最后的结果是8.  
再看下面这个情况

**\[cpp\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **class** A  
2.  \{  
3.     **public**:  
4.        **int** i;  
5.        **int** l;  
6.        **static** **int** s;  
7.        **int** add(**int** x,**int** y)\{ **return** (x+y)\};  
8.  \};

此时sizeof(A)大小仍为8，这里留给读者去思考为什么？（^-^）。

当类里面含有虚函数时，情况会如何呢？

**\[cpp\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **class** A  
2.  \{  
3.     **public**:  
4.       **int** i;  
5.       **int** l;  
6.       **static** **int** s;  
7.       **virtual** **void** Say()\{\};  
8.       **int** add(**int** x,**int** y)\{ **return** (x+y)\};  
9.  \};

因为含有虚函数，所以类里面将含有一个虚指针vptr，指向该类的虚表vtbl，一个指针占用四字节的地址，所以sizeof(A) = 12  
虚指针放在类实例地址的最低位置，  
比如 A \*a = new A;   
我们可以这样给变量i赋值  
int \*p = (int \*)a;  
p++;  
\*p = 1;//把i的值赋为1.  
如果类作为派生类，内存将如何分配呢？  
这种情况虽然有些复杂，但并不是说不好理解。  
他有多少个父类每个父类的大小加起来在加上自身就是sizeof的大小。

[http_blog.csdn.net_chenyiming_1990_article_details_10308507]: http://blog.csdn.net/chenyiming_1990/article/details/10308507
[view plain]: http://blog.csdn.net/chenyiming_1990/article/details/10308507#

发表评论取消回复

表情：

评论列表（有 0 条评论，206人围观）

还没有评论，来说两句吧...

相关阅读

相关 C++:42---类的内存大小

一、类内存的特点类内无任何成员变量时，默认为1字节类内成员遵循内存的对齐补齐规则（与结构体的对齐补齐一样）函数不占内存(存在代码段) 有继

不念不忘少年蓝@/ 2022年12月29日 09:52/ 0 赞/ 209 阅读

相关 C++中虚函数工作原理和(虚)继承类的内存占用大小计算

转载请标明出处，原文地址：[http://blog.csdn.net/hackbuteer1/article/details/7883531][http_blog.csdn.n

清疚/ 2022年09月21日 15:20/ 0 赞/ 162 阅读

相关 c++拾遗之数据类型占用内存大小总结

/\\\\\\\\\\\\\\\\\\\\\\\\\ 一：整形 int 4字节 long int 4字节 short int

「爱情、让人受尽委屈。」/ 2022年08月27日 03:21/ 0 赞/ 208 阅读

相关关于C++中类的占用内存大小

所有的函数都是存放在代码区的,不管是全局函数，还是成员函数。sizeof访问的程序的数据段。 1. 类的大小为类的非静态成员数据的类型大小之和，也就是说静态成员数据不作考虑

本是古典何须时尚/ 2022年08月26日 15:12/ 0 赞/ 207 阅读

相关 C++中虚函数工作原理和(虚)继承类的内存占用大小计算

转载请标明出处，原文地址：[http://blog.csdn.net/hackbuteer1/article/details/7883531][http_blog.csdn.n

超、凢脫俗/ 2022年08月20日 13:23/ 0 赞/ 158 阅读

相关类内存占用

类所占内存的大小是由成员变量（静态变量除外）决定的，成员函数是不计算在内的。成员函数还是以一般的函数一样的存在。a.fun()是通过fun(a.this)来调用的。所谓成员

阳光穿透心脏的1/2处/ 2022年08月09日 05:10/ 0 赞/ 185 阅读

相关 C++中虚函数工作原理和(虚)继承类的内存占用大小计算

一、虚继承情况下类的内存大小计算当每个基类中有多个虚函数时，并且在虚继承的情况下，内存是如何分配的，如何计算类的大小，下面举例说明： \include<iostream>

青旅半醒/ 2022年08月05日 02:22/ 0 赞/ 177 阅读

相关 java中获取对象所占用的内存大小

java中快速获取某个对象所占用的内存大小： <dependency> <groupId>org.apache.lucene</groupId>

川长思鸟来/ 2022年07月15日 08:43/ 0 赞/ 285 阅读

相关 C++中虚函数工作原理和（虚）继承类的内存占用大小计算

一、虚函数的工作原理虚函数的实现要求对象携带额外的信息，这些信息用于在运行时确定该对象应该调用哪一个虚函数。典型情况下，这一信息具有一种被称为 vptr（vi

素颜马尾好姑娘i/ 2022年02月28日 03:16/ 0 赞/ 229 阅读

相关 C++类占内存大小

总结：空类占用1个字节，非空类的大小=非静态成员变量占用大小（静态变量不占内存）+虚函数占用内存（4字节，不管有多少个虚函数）+字节对齐的开销（成员函数不算入类的空间），子类大

我不是女神ヾ/ 2021年11月08日 23:31/ 0 赞/ 357 阅读