C++_类和结构体所占内存大小，静态成员问题

最新推荐文章于 2023-04-08 20:29:54 发布
最新推荐文章于 2023-04-08 20:29:54 发布
阅读量1.2k 收藏 5
点赞数 1
分类专栏： C++随笔 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asdasdde/article/details/118994060
版权

C++_类和结构体所占内存大小，静态成员问题

静态成员未初始化或者未调用（当然静态成员必须类外初始化才能调用）是不占内存的。静态成员不占类或结构体的内存
静态成员函数同样只声明未定义同样不占内存

指针在64位机8个字节，32位机4个字节，
可以参考指针大小与32位、64位系统

// vector::emplace_back
#include <iostream>
#include <vector>
struct dddd{
    int x;
    int y;
    static int z;
    dddd(int a,int b):x(a),y(b){}
    void dd(){}
    static int cc();
};
int dddd::cc(){}
int dddd::z=0;
int main ()
{
  /*std::vector<dddd> myvector;

  myvector.emplace_back (100,200);
  std::cout << "myvector contains:";
  /*for (auto& x: myvector)
    std::cout << ' ' << x.second;
  std::cout << '\n';*/
    dddd::z=0;
    std::cout<<sizeof(dddd)<<std::endl;
  return 0;
}

1.结构体所占大小计算

结构体存在内存对齐，类(对象)也如此，甚至于所有变量在内存中的存储也有对齐一说(只是这些对程序员是透明的，不需要关心)。实际上，这种对齐是为了在空间与复杂度上达到平衡的一种技术手段，简单的讲，是为了在可接受的空间浪费的前提下，尽可能的提高对相同运算过程的最少(快)处理。

先看以下程序

#include<stdio.h>
union ss
{
  int a;
  char b;
};
struct MyStruct
{
  int temp1;//4个字节
  char temp2;//一个字节，补齐3个字节
  ss aa;//4个字节
  char temp3;//一个字节
  char temp4;//一个字节，补齐两个字节
};
int main()
{
  printf("%d",sizeof(MyStruct));
  return 0;
}

对齐规则是按照成员的声明顺序，依次安排内存，对齐字节数为最大成员变量的字节大小，偏移量为最大成员变量的字节数的整数倍，在这个程序中对齐字节数为4

#include<stdio.h>
union ss
{
    int a;
    double b;
};
struct MyStruct
{
    int temp1;//4个字节
    char  temp2;//1个字节，对齐是8个字节，还需3个字节补齐
    ss aa;//8个字节
    char temp3;//1个字节
    short temp4;//2个字节，补齐还需要5个字节
};
int main()
{
    printf("%d", sizeof(MyStruct));
    return 0;
}

aa是最大字节8个，所以temp2开始补齐，所以总的为24

#include<stdio.h>
union ss
{
    int a;
    double b;
};
struct MyStruct
{
    int temp1;//4个字节
    char  temp2;//1个字节
    
    char temp3;//1个字节,对齐是8个字节，还需2个字节补齐
    ss aa;//8个字节
    
    short temp4;
    short temp5;
    short temp6;
    short temp7;
    short temp8;//2个字节，补齐还需要6个字节
};
int main()
{
    printf("%d", sizeof(MyStruct));
    return 0;
}

大小为32

#include<stdio.h>
union ss
{
    int a;
    double b;
};
 
struct student
{
    int name;
    char sex;
    double num;
 
};
struct MyStruct
{
    int temp1;//4个字节
    char  temp2;//1一个字节，补齐3个字节
    ss aa;//8个字节
    char temp3;//一个字节
    short temp4;//2个字节,补齐5个字节
    student people;//16个字节
};
int main()
{
    printf("%d", sizeof(MyStruct));
    return 0;
}

大小为40；

此时需要注意的是，对齐字节数8个字节，而不是16个字节。student people 对象内部先进行一次对齐，然后如果如果是外面对齐字节数的整数倍就不需要

#include<stdio.h>
union ss
{
    int a;
    double b;
};
 
struct student
{
    //int name;
    //char sex;
    int num;
 
};
struct MyStruct
{
    int temp1;//4个字节
    char  temp2;//1一个字节，补齐3个字节
    ss aa;//8个字节
    char temp3;//1个字节
    short temp4;//2个字节
    student people;//4个字节，补齐一个字节
};
int main()
{
    printf("%d", sizeof(MyStruct));
    return 0;
}

大小为24

空结构体大小为1

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

2.类内存大小计算

类只用计算成员变量与指针的大小，空类也会被实例化，所以编译器会给空类隐含的添加一个字节，这样空类实例化之后就有了独一无二的地址了。所以空类的sizeof为1。静态成员变量和静态成员函数都是类的所有对象共享的，静态成员变量存放在全局存储区，静态成员变量和静态成员函数在编译时就已经在全局区分配的内存。

#include<iostream>
using namespace std;
class student
{
    static int b;
    static void func();
};
int main()
{
    cout << sizeof(student) << endl;
    return 0;
}

大小为1

class CBase 
{ 
public: 
CBase(void); 
virtual ~CBase(void); //1个字节
private: 
int  a; 
char *p; //1个字节补齐3个字节
};

大小为12，虚函数会产生一个虚函数指针，指针大小为4个字节，虚函数指针指向虚函数表。但是并不是每一个虚函数都会产生一个虚函数指针，同一个类中的所有虚函数只会产生一个虚函数指针。

#include<iostream>
using namespace std;
class student
{
    int a;
    char c;
    static int b;
public:
    static void func();
    virtual void fly();
};
class student1: public student
{
    int d;//4个字节
};
int main()
{
    cout << sizeof(student1) << endl;
    return 0;
}

大小为12派生类会继承父类的成员变量和虚函数等，所以子类的内存大小是在父类的内存大小的基础上加上自己增加的内存大小。G++实测24个字节，我的理解是虚函数指针8个字节（实测只有虚函数的情况下），int，char补齐8个字节，继承按道理讲是直接16+4=20个字节，我的理解是补齐4个字节，所以24个字节，实测也是这样的

#include<iostream>
using namespace std;
class student
{
    int a;
    char c;
    static int b;
public:
    static void func();
    virtual void fly();
};
class student1: public student
{
    int d;//4个字节
    int c;//4个字节
};
int main()
{
    cout << sizeof(student1) << endl;
    return 0;
}

24个字节

#include<iostream>
using namespace std;
class student
{
    int a;
    char c;
    static int b;
public:
    static void func();
    virtual void fly();
};
class student1: public student
{
    int d;//4个字节
    int c;//4个字节
    int a;//4个字节，补齐4个
};
int main()
{
    cout << sizeof(student1) << endl;
    return 0;
}

32个字节

#include<iostream>
using namespace std;
class student
{
    int a;
    char c;
    static int b;
public:
    static void func();
    virtual void fly();
};
class student1: public student
{
    int d;
public:
    void fly();
    virtual void eat();
};
int main()
{
    cout << sizeof(student1) << endl;
    return 0;
}

16个，g++64位机实测24

测试如下代码：发现原因，虚函数指针在64位机8个字节，在32位机是4个字节，不论有几个虚函数但只有一个虚函数指针，所以即使存在3个虚函数大小还是8或4；

#include<iostream>
using namespace std;
class student
{
    int a;
    char c;
    static int b;
public:
    static void func();
    virtual void CC(){};
};
class student1
{
    //int d;
public:
    void CC(){std::cout<<"1";};
    virtual void eat(){};
    virtual void at(){};
    virtual void t(){};
};
int main()
{
    student * aa;
    student1 bb;
    //aa=&bb;
    //aa->CC();
    std::cout<<sizeof(student1)<<endl;
    return 0;
}

64位机G++测试结果为8

#include<iostream>
using namespace std;
class student
{
    int a;
    char c;
    static int b;
public:
    static void func();
    virtual void CC(){};
};
class student1:public student
{
    //int d;
public:
    void CC(){std::cout<<"1";};
    virtual void eat(){};
    virtual void at(){};
    virtual void t(){};
};
int main()
{
    student * aa;
    student1 bb;
    //aa=&bb;
    //aa->CC();
    std::cout<<sizeof(student1)<<endl;
    return 0;
}

G++64位机测试为16，int d加上 测试为24

可以看出按照虚指针的大小进行补齐；

问题：子类声明了一个虚函数且该虚函数是父类中没有的虚函数为什么子类没有新产生一个虚函数指针。

这个涉及到内存布局问题，首先是基类产生了一个虚函数指针，这个虚函数指针会指向虚函数表，表中存放的是基类的虚函数。子类也会继承到这个虚函数指针，虚函数指针指向虚函数表，表中先是存放基类的虚函数，再存放子类的基函数，如果子类重载了父类的某些虚函数，那么新的虚函数将虚函数表中父类对应的虚函数覆盖

虚继承——空类

#include<iostream>
using namespace std;
class student
{
     
};
class student1: virtual student
{
 
};
int main()
{
    cout << sizeof(student1) << endl;
    return 0;
}

g++测试为64位机8个字节，如上虚指针的红字部分

#include<iostream>
using namespace std;
class student
{
    int a;
    char c;
    //static int b;
public:
    //static void func();
    virtual void fly();
};
class student1: virtual student
{
    int d;
public:
    void fly();
    //virtual void eat();
};
int main()
{
    cout << sizeof(student1) << endl;
    return 0;
}

G++测试为32；按8位补齐因为虚继承会再产生一个虚函数指针，去指向对应的基类，防止子类继承多个一样的基类，造成资源浪费

#include<iostream>
using namespace std;
class student
{
    int a;
    char c;
    //static int b;
public:
    //static void func();
    virtual void fly();
};
class student1: virtual student
{
    int d;
public:
    void fly();
    virtual void eat();
};
int main()
{
    cout << sizeof(student1) << endl;
    return 0;
}

64位机G++测试为32；按8位补齐。此时是子类声明的虚函数是父类没有的，则此时子类会再产生一个虚函数指针，如果此时子类的所有虚函数都是继承自基类的，则不会产生虚函数指针。

参考：struct和class内存大小的计算

C++中 类 和 结构体所占内存大小

勿在浮沙築高臺
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 类和对象总结
01-20
对象：客观世界里的一切事物都可以看作是一个对象，每一个对象应当具有属性（静态特征，比如一个班级，一个专业，一个教室）和行为（动态特征，例如：学习，开会，体育比赛等）两个要素。 对象是由一组属性和一组...
C++语言 第7章 文件和结构体(C++版)_codes.rar
06-04
C++语言 第7章 文件和结构体(C++版)_codes.rar
面试经验|Visual C++：深圳冰川网络
haimianjie2012的专栏
02-16 1177
自我介绍 你期望的薪资 结构体所占存储空间 http://www.cnblogs.com/-zhangnian/p/6422559.html 空的类是会占用内存空间的，而且大小是1，原因是C++要求每个实例在内存中都有独一无二的地址。 （一）类内部的成员变量： 普通的变量：是要占用内存的，但是要注意对齐原则（这点和struct类型很相似）。 static修饰的静态变量：不...
C++基础总结系列之【内存结构】
存星的博客
03-19 1422
目录 内存分区 内存图 内存四区 栈区 堆区 数据区 代码区 堆与栈的区别 动态内存管理 malloc、calloc、realloc new/delete new和malloc的区别 智能指针 内存对齐 what why 没有内存对齐机制 引入内存对齐机制 how 对齐系数 有效对齐值（对齐单位） 结构体内存对齐规则 类内存对齐规则 常见的内存错误（如何避免内存泄漏） 内存分区 内存图 内存四区 栈区 作用：保存局部变量、函数调用参数
c++ 内存结构
AlbertHMY的博客
12-16 943
c++ STL笔记C/C++ 内存结构C++内存结构分类全局变量，全局函数普通类的内存模型类成员非静态成员内存对齐的原则：确定对齐单位：填充内存：静态成员成员函数非静态成员函数静态成员函数补充&总结 C/C++ 内存结构 C++内存结构分类 全局变量，全局函数 static字符不影响全局变量和函数在内存中的表现形式，唯一区别是加了static修饰的值外部不可见。 全局函数都位于代码段，全局变量根据其是否赋有初值，是否被const修饰区分： 未被const修饰，赋初值：位于读写数据段； 未被con
c语言之自定义类型
Leetp
03-07 603
union enum struct 结构体内存对齐
C++类的静态成员、动态内存分配和复制构造函数
sinat_18187903的博客
04-03 790
对于C++类使用静态成员对象有进一步的认识。通过了解复制构造函数，将会使设计的类更加完善。对使用new和delete会更清晰，避免程序设计过程中出现异常。
C++之类成员所占内存大小问题总结
weixin_30708329的博客
09-13 280
1.空类所占字节数为1，可见代码如下 #include <iostream> using namespace std; class Parent { }; class Child:public Parent { public: int b ; }; int main(int argc, char* argv[]) { Chi...
C/C++中的内存对齐问题
DayDayUp
12-06 409
内存对齐的三条规则 数据成员对齐规则，结构体(struct)(或联合(union))的数据成员，第一个数据成员存放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员(只要该成员有子成员，比如数组、结构体等)大小的整数倍开始(如：int 在 64bit 目标平台下占用 4Byte，则要从4的整数倍地址开始存储) 结构体作为成员，如果一个结构体里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储 结构体的总大小，即sizeof的结果，必须是其内部最大成
C++静态成员函数不能调用非静态成员变量(详解)
12-26
然而非静态成员变量和非静态成员函数是针对类的对象而言。 然而从本质上来说类的静态成员函数的函数形参中没有默认的this指针，导致不能调用具体实例对象的成员。 下面我们来测试一下： 先在静态成员函数中调用静态...
C#调用C++DLL传递结构体数组的终极解决方案
12-31
C#调用C++DLL传递结构体数组的终极解决方案 在项目开发时，要调用C++封装的DLL，普通的类型C#上一般都对应，只要用DllImport传入从DLL中引入函数就可以了。但是当传递的是结构体、结构体数组或者结构体指针的时候，...
c++中关于结构体长度的计算问题.pdf
11-20
"C++结构体长度计算问题" 一、结构体长度计算的重要性 在C++编程中，结构体的长度计算是一个非常重要的问题。很多开发者都知道，结构体的sizeof值，不是简单的将其中各元素所占字节相加，而是要考虑到存储空间的...
[C/C++语言]全局变量、局部变量、静态全局变量和静态局部变量运行时内存分配方式研究
zhanghui962623727的博客
09-15 2621
0、前言 在分析一个程序的堆栈、bss段、text段、RO、RW、ZI等概念时，首先区分一下程序进程和程序文件，同时区分一下哈佛结构和冯诺依曼结构。 程序进程就是程序运行时的程序，程序文件是编译后生成的可执行文件，比如.bin文件等。 哈佛结构和冯诺依曼结构的主要区别就是处理器能不能实现取指令和取数据的并发进行。嵌入式芯片中主要是哈佛结构，PC机上是冯诺依曼结构。 （1）经典的哈佛结构： 程序存储器和数据存储器是各自独立的存储器。处理器应该有两套总线，一套是程序存储器的数据和地址总线，一套是数据存.
C++ vector容器剖析
weixin_43371860的博客
04-08 1260
在向vector中加入一个新元素时，若数组中的数据已满（大小=容量），则此时需要对数组进行扩充，扩充的实现方式为：构造一个容量为原数组两倍的新数组，将原来数组的数据拷贝到新数组中，然后插入新的元素，这一过程会调用大量的构造函数（构造新的数组）和析构函数（销毁原数组）。vector类中的数据包括三个指针，如图1所示，分别指向数组的第一个数据的位置、数组的最后一个数据的下一个位置和数组空间的最后一个位置的下一个位置，因此vector的大小是12字节（sizeof(vector) = 12）
c++ ---静态成员与函数
Rejective的博客
09-26 395
c++静态成员与函数 注意事项 1、静态成员属性需要在类内声明，在类外初始化，否则会报错 2、静态成员函数只能访问静态成员变量，而非静态成员函数不能访问静态成员属性 3、静态成员函数和成员属性是分配在全局区，而非静态成员属性和变量在栈区 所有对象共享一份静态成员属性，以及共享同一个静态成员函数 4、由于静态成员函数和属性不属于类，所以有两种访问方式 （1）通过对象来访问 （2）通过类名访问 5、同样静态成员属性和成员函数若为私有或保护权限，则也无法在类外进行访问 代码部分 静态成员属性 #include&l
结构体的内存占用及如何正确初始化
qq_38149046的博客
04-08 1907
（一） 内存占用规则首先定义一个简单的结构体，包含四种常用的结构类型。其中char占用1字节、int占用4字节、float占用4字节、double占8字节。struct Coordinate { char x; int y; float z; double t; }按照正常计算占用的内存为 1+...
c语言中变量不初始化会怎么样？
分享个人学习经历
10-14 2931
如果一个变量i没有进行初始化，就将其打印出来，那么变量i会和内存中的某一个单元产生关联。然后变量i就代表那个内存单元了，如果要想操作该内存单元只需要通过变量i就可以了。所以内存中到底放的是什么？
C/C++结构体内存对齐
mrqiuwen的博客
10-06 1919
C/C++结构体内存对齐原理的详细解释，详细介绍对齐规则，并利用一些示例进行讲解
2020-10-18C++笔记之C/C++之字符串赋值
勿在浮沙築高台
10-18 2700
C++笔记之C/C++之字符串赋值 C 序号 函数 & 目的 1 strcpy(s1, s2); 复制字符串 s2 到字符串 s1。 2 strcat(s1, s2); 连接字符串 s2 到字符串 s1 的末尾。 3 strlen(s1); 返回字符串 s1 的长度。 4 strcmp(s1, s2); 如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回小于 0；如果 s1>s2 则返回大于 0。
C++结构体的静态变量和类的静态变量是一样含义吗
最新发布
06-09
C++中结构体的静态变量和类的静态变量是完全一样的。结构体和类的区别仅在于默认的访问控制（默认是`public`和`private`），以及默认的继承方式（结构体默认是`public`继承，类默认是`private`继承）。 以下是一个简单的例子，展示了结构体和类中的静态变量的定义和访问： ```cpp #include <iostream> struct MyStruct { static int staticVar; }; int MyStruct::staticVar = 0; class MyClass { public: static int staticVar; }; int MyClass::staticVar = 0; int main() { MyStruct s; s.staticVar = 1; std::cout << "MyStruct staticVar: " << MyStruct::staticVar << std::endl; MyClass c; c.staticVar = 2; std::cout << "MyClass staticVar: " << MyClass::staticVar << std::endl; return 0; } ``` 在上述代码中，我们分别定义了一个结构体`MyStruct`和一个类`MyClass`，并在它们中都定义了一个静态变量`staticVar`。在`main`函数中，我们分别创建了一个`MyStruct`对象`s`和一个`MyClass`对象`c`，并分别给它们的`staticVar`赋值。最后，我们输出了两个静态变量的值，可以看到它们的定义和访问方式是完全一样的。 因此，C++中结构体和类的静态变量是没有任何区别的。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值