精华内容
下载资源
问答
  • 一个结构体变量的指针就是该变量占据的内存段的起始地址。可以设一个指针变量,用来指向一个结构体变量,此时该指针变量的值是结构体变量的起始地址。指针变量也可以用来指向结构体数组中的元素。 声明一个...

    一个结构体变量的指针就是该变量所占据的内存段的起始地址。可以设一个指针变量,用来指向一个结构体变量,此时该指针变量的值是结构体变量的起始地址。指针变量也可以用来指向结构体数组中的元素。

    声明一个结构体变量,无论是否初始化,都开辟内存,声明一个结构体指针变量,对其初始化的时候才会开辟内存。

    A a[3];  a是A型的,有3个,当然分配A乘3大小的空间

    A* a;    a是A*型的,当然只分配A*大小的空间,而不会分配A大小的空间

    结构体变量分配结构体本身大小的空间,结构体指针分配4个字节,其实任何类型的指针都是分配四个字节的指针空间。
    所以:
    A a[3]; //a里面是三个A变量,所以分配三个结构体大小
    A *a;  //a是一个指针,分配4个字节,就算A再大,a也只是4个字节,因为任何类型的指针都是4个字节。要使用a,必须先要对指针初始化,也即分配空间了。
    如:
    A *a;
    a = (A*)malloc(sizeof(A));

    我们完全可以撇开结构体,把问题简单化成int类型来说明这个指针问题:
    int a1[10];
    int *a2;

    很容易知道,a1是包含10个int的数组,大小也就是10*sizeof(int)。我们可以直接使用a1不用再进行什么初始化或者分配空间,因为数组a1里面本身存放的就是int变量本身了。

    然后a2,是一个int*的东西,也就是整型指针,a2不能存放int变量,它只能存放地址,一个int变量的地址。如果要使用a2,必须首先对a2初始化,即将它指向一个int变量的地址,如:
    a2 = (int*)malloc(sizeof(int));
    或者
    int i = 10;
    a2 = &i;
    所以,malloc函数的作用是首先声明一个变量,然后返回该变量的地址。
    所以:a2 = (int*)malloc(sizeof(int)) 的含义就是把该变量的地址赋值给a2,和a = &i 本质上并没有什么不同,只是一个变量是栈上,一个是堆上,都是一个地址赋值。
    【例7.3】指向结构体变量的指针的应用。

    
        
    1. #include <iostream>
    2. #include <string>
    3. using namespace std;
    4. int main( )
    5. {
    6. struct Student//声明结构体类型student
    7. {
    8. int num;
    9. string name;
    10. char sex;
    11. float score;
    12. };
    13. Student stu;//定义Student类型的变量stu
    14. Student *p=&stu;//定义p为指向Student类型数据的指针变量并指向stu
    15. stu.num=10301;//对stu中的成员赋值
    16. stu.name="Wang Fun";//对string变量可以直接赋值
    17. stu.sex='f';
    18. stu.score=89.5;
    19. cout<<stu. num<<" "<<stu.name<<" "<<stu.sex<<" "<<
    20. stu.score<<endl;
    21. cout<<p -> num<<" "<<(*p).name<<" "<<(*p).sex<<" "<<(*p).score<<endl;
    22. return 0;
    23. }
    程序运行结果如下:
    10301 Wang Fun f 89.5 (通过结构体变量名引用成员)
    10301 Wang Fun f 89.5 (通过指针引用结构体变量中的成员)
    两个cout语句输出的结果是相同的。

    为了使用方便和使之直观,C++提供了指向结构体变量的运算符->, 例如p->num表示指针p当前指向的结构体变量中的成员num。
        p->num 和(*p).num等价。
    同样
        p->name等价于(*p).name。
    也就是说,以下3种形式等价:
    • 结构体变量.成员名。如stu.num。
    • (*p).成员名。如(*p).num。
    • p->成员名。如p->num。

    “->”称为指向运算符。

    请分析以下几种运算:
    • p->n 得到p指向的结构体变量中的成员n的值。
    • p->n++ 得到p指向的结构体变量中的成员n的值,用完该值后使它加1。
    • ++p->n 得到p指向的结构体变量中的成员n的值,并使之加1,然后再使用它。

    用结构体变量和指向结构体变量的指针构成链表

    链表是一种常见的重要的数据结构。图7.8表示最简单的一种链表(单向链表)的结构。


    图7.8

    链表有一个“头指针”变量,图中以head表示,它存放一个地址。该地址指向一个元素。链表中的每一个元素称为“结点”,每个结点都应包括两个部分:
    • 一是用户需要用的实际数据,
    • 二是下一个结点的地址。

    可以看到链表中各元素在内存中的存储单元可以是不连续的。要找某一元素,可以先找到上一个元素,根据它提供的下一元素地址找到下一个元素。

    可以看到,这种链表的数据结构,必须利用结构体变量和指针才能实现。

    可以声明一个结构体类型,包含两种成员,一种是用户需要用的实际数据,另一种是用来存放下一结点地址的指针变量。

    例如,可以设计这样一个结构体类型:
    
        
    1. struct Student
    2. {
    3. int num;
    4. float score;
    5. Student *next; //next指向Student结构体变量
    6. };
    其中成员num和score是用户需要用到的数据,相当于图7.8结点中的A, B, C, D。next是指针类型的成员,它指向Student类型数据(就是next所在的结构体类型)。用这种方法就可以建立链表。见图7.9。


    图7.9

    图中每一个结点都属于Student类型,在它的成员next中存放下一个结点的地址,程序设计者不必知道各结点的具体地址,只要保证能将下一个结点的地址放到前一结点的成员next中即可。

    下面通过一个例子来说明如何建立和输出一个简单链表。

    【例7.4】建立一个如图7.9所示的简单链表,它由3个学生数据的结点组成。输出各结点中的数据。
    
        
    1. #define NULL 0
    2. #include <iostream>
    3. using namespace std;
    4. struct Student
    5. {
    6. long num;
    7. float score;
    8. struct Student *next;
    9. };
    10. int main( )
    11. {
    12. Student a,b,c,*head,*p;
    13. a. num=31001;
    14. a.score=89.5; //对结点a的num和score成员赋值
    15. b. num=31003;
    16. b.score=90; //对结点b的num和score成员赋值
    17. c. num=31007;
    18. c.score=85; //对结点c的num和score成员赋值
    19. head=&a; //将结点a的起始地址赋给头指针head
    20. a.next=&b; //将结点b的起始地址赋给a结点的next成员
    21. b.next=&c; //将结点c的起始地址赋给b结点的next成员
    22. c.next=NULL; //结点的next成员不存放其他结点地址
    23. p=head; //使p指针指向a结点
    24. do
    25. {
    26. cout<<p->num<<" "<<p->score<<endl; //输出p指向的结点的数据
    27. p=p->next; //使p指向下一个结点
    28. } while (p!=NULL); //输出完c结点后p的值为NULL
    29. return 0;
    30. }
    本例是比较简单的,所有结点(结构体变量)都是在程序中定义的,不是临时开辟的,也不能用完后释放,这种链表称为静态链表。对各结点既可以通过上一个结点的next指针去访问,也可以直接通过结构体变量名a, b, c去访问。

    动态链表则是指各结点是可以随时插入和删除的,这些结点并没有变量名,只能先找到上一个结点,才能根据它提供的下一结点的地址找到下一个结点。只有提供第一个结点的地址,即头指针head,才能访问整个链表。如同一条铁链一样,一环扣一环,中间是不能断开的。

    建立动态链表,要用到后面介绍的动态分配内存的运算符new和动态撤销内存的运算符delete。

    用户栈是(运行时创建)是用户存放程序临时创建的局部变量,不包括静态变量,除此之外,在函数调用时,其参数也会被压入栈,并且带导函数调用结束后,函数的返回值也会存放到栈中。

    堆是用于存放程序进程中被动态分配的内存段,它的大小不固定,可动态扩展,结束后必须free掉。

    展开全文
  • 一个结构体变量定义完之后,其在内存中的存储并不等于其包含元素的宽度之和。 例一: #include <iostream> using namespace std; struct X {

    一个结构体变量定义完之后,其在内存中的存储并不等于其所包含元素的宽度之和。
    例一:

                                      #include <iostream>
    
                                      using namespace std;
    
                                         struct X
    
                                         {
    
                                              char a;
    
                                              int b;
    
                                              double c;
    
                                         }S1;
    
    
    
                                     void main()
    
                                    {
    
                                         cout << sizeof(S1) << endl;
    
                                         cout << sizeof(S1.a) << endl;
    
                                         cout << sizeof(S1.b) << endl;
    
                                         cout << sizeof(S1.c) << endl;
    
                                    }
    
     比如例一中的结构体变量S1定义之后,经测试,会发现sizeof(S1)= 16,其值不等于sizeof(S1.a) = 1、sizeof(S1.b) = 4和 sizeof(S1.c) = 8三者之和,这里面就存在存储对齐问题。
    
    ***原则一:结构体中元素是按照定义顺序一个一个放到内存中去的,但并不是紧密排列的。从结构体存储的首地址开始,每一个元素放置到内存中时,它都会认为内存是以它自己的大小来划分的,因此元素放置的位置一定会在自己宽度的整数倍上开始(以结构体变量首地址为0计算)。***
    
    比如此例,首先系统会将字符型变量a存入第0个字节(相对地址,指内存开辟的首地址);然后在存放整形变量b时,会以4个字节为单位进行存储,由于第一个四字节模块已有数据,因此它会存入第二个四字节模块,也就是存入到4~8字节;同理,存放双精度实型变量c时,由于其宽度为8,其存放时会以8个字节为单位存储,也就是会找到第一个空的且是8的整数倍的位置开始存储,此例中,此例中,由于头一个8字节模块已被占用,所以将c存入第二个8字节模块。整体存储示意图如图1所示。
    
    
    
    考虑另外一个实例。
    

    例二:

                                           struct X
    
                                           {
    
                                                char a;
    
                                                double b;
    
                                                int c;
    
                                            }S2;
    
    在例二中仅仅是将double型的变量和int型的变量互换了位置。测试程序不变,测试结果却截然不同,sizeof(S2)=24,不同于我们按照原则一计算出的8+8+4=20,这就引出了我们的第二原则。
    
    
    
    
    
    ***原则二:在经过第一原则分析后,检查计算出的存储单元是否为所有元素中最宽的元素的长度的整数倍,是,则结束;若不是,则补齐为它的整数倍。***
    
    例二中,我们分析完后的存储长度为20字节,不是最宽元素长度8的整数倍,因此将它补齐到8的整数倍,也就是24。这样就没问题了。其存储示意图如图2所示。
    
    
    
    掌握了这两个原则,就能够分析所有数据存储对齐问题了。再来看几个例子,应用以上两个原则来判断。
    

    例三:

                                              struct X
    
                                              { 
    
                                                   double a;
    
                                                   char b;
    
                                                   int c;     
    
                                              }S3;
    
    首先根据原则一来分析。按照定义的顺序,先存储double型的a,存储在第0~7个字节;其次是char型的b,存储在第8个字节;接下来是int型的c,顺序检查后发现前面三个四字节模块都被占用,因此存储在第4个四字节模块,也就是第12~15字节。按照第一原则分析得到16个字节,16正好是最宽元素a的宽度8的整数倍,因此结构体变量S3所占存储空间就是16个字节。存储结构如图3所示。
    

    例四:

                                              struct X
    
                                              { 
    
                                                   double a;
    
                                                   char b;
    
                                                   int c;
    
                                                   char d;   
    
                                              }S4;
    
    
    
    仍然首先按照第一原则分析,得到的字节数为8+4+4+1=17;再按照第二原则补齐,则结构体变量S4所占存储空间为24。存储结构如图4所示:
    

    例五:

                                              struct X
    
                                              { 
    
                                                   double a;
    
                                                   char b;
    
                                                   int c;
    
                                                   char d;
    
                                                   int e; 
    
                                               }S5;
    
    同样结合原则一和原则二分析,可知在S4的基础上在结构体内部变量定义最后加入一个int型变量后,结构体所占空间并未增加,仍为24。存储结构示意图如图5所示。
    

    例六:

    如果将例五中加入的变量e放到第一个定义的位置,则情况就不同了。结构体所占存储空间会变为32。其存储结构示意图如图6所示。
    
                                              struct X
    
                                              { 
    
                                                  int e;
    
                                                  double a;
    
                                                  char b;
    
                                                  int c;
    
                                                  char d;
    
                                              }S6;
    
    
    
    补充:前面所介绍的都是元素为基本数据类型的结构体,那么含有指针、数组或是其它结构体变量或联合体变量时该如何呢?
    
    1.包含指针类型的情况。只要记住指针本身所占的存储空间是4个字节就行了,而不必看它是指向什么类型的指针。
    

    例七:

                    struct X              struct Y               struct Z
    
                    {                     {                      {     
    
                       char *a;              int *b;                 double *c;
    
                    };                     };                     };
    
    经测试,可知sizeof(X)、sizeof(Y)和sizeof(Z)的值都为4。
    
    2.含有构造数据类型(数组、结构体和联合体)的情况。首先要明确的是计算存储空间时要把构造体看作一个整体来为其开辟存储空间;其次要明确的是在最后补齐时是按照所有元素中的基本数据类型元素的最长宽度来补齐的,也就是说虽然要把构造体看作整体,但在补齐的时候并不会按照所含结构体所占存储空间的长度来补齐的(即使它可能是最长的)。
    

    例八:

                                      struct X
    
                                     {
    
                                          char a;
    
                                          int b;
    
                                          double c;
    
                                      };
    
                                      struct Y
    
                                      {
    
                                           char a;
    
                                           X b;
    
                                       };
    
    经测试,可知sizeof(X)为16,sizeof(Y)为24。即计算Y的存储长度时,在存放第二个元素b时的初始位置是在double型的长度8的整数倍处,而非16的整数倍处,即系统为b所分配的存储空间是第8~23个字节。
    
    如果将Y的两个元素char型的a和X型的b调换定义顺序,则系统为b分配的存储位置是第0~15个字节,为a分配的是第16个字节,加起来一共17个字节,不是最长基本类型double所占宽度8的整数倍,因此要补齐到8的整数倍,即24。测试后可得sizeof(Y)的值为24。
    
    由于结构体所占空间与其内部元素的类型有关,而且与不同类型元素的排列有关,因此在定义结构体时,在元素类型及数量确定之后,我们还应该注意一下其内部元素的定义顺序。
    
    展开全文
  • 原文链接:... 一个结构体变量占多大内存空间的问题   直接来看相同数据结构体的几种书写的格式吧。 格式一: 1. struct tagPhone  2. {  3. char A;  4. int B;  5. ...

    原文链接:http://blog.sina.com.cn/s/blog_75a2ecd20102xca0.html

    一个结构体变量占多大内存空间的问题

     

    直接来看相同数据结构体的几种书写的格式吧。

    格式一:

    1.  struct tagPhone    

    2.  {    

    3.       char   A;    

    4.       int    B;    

    5.       short  C;    

    6.  }Phone1;  

    格式二:  

    1.  struct tagPhone    

    2.  {    

    3.       char   A;    

    4.       short  C;    

    5.       int    B;    

    6.  }Phone2;   

    格式三:  

    1.  struct tagPhone3    

    2.  {    

    3.       char    A;    

    4.       char   B[2];    

    5.       char    C[4];    

    6.  }Phone3;   

    格式四:

    1.  struct tagPhone3    

    2.  {    

    3.       char    A;    

    4.       double  B[2];    

    5.       char    C[4];    

    6.  }Phone4;   

    例题:请问下面定义的结构体变量aa在计算机内存中占用多少字节?

    #include

    main()

    {

    struct  student

    {   float    height;

    short int  age ;

    char     sex ;

    }aa;

    printf("%d\n",sizeof(aa));  //屏幕上将显示多少?

    }

    错误解答:我们都知道,char类型占用1个字节,float型占用4个字节,short int类型占用2个字节,int型在VC6.0中占用4个字节(TC2.0中占用2个字节),long占用8个字节,double占用8个字节。因此,我们可能会犯一个错误就是直接4+2+1=7,结构体aa占用7个字节。这是错的。

    错误分析:计算结构体大小时需要考虑其内存布局,编译系统为了提高计算机访问数据的效率,在安排结构体每个成员的时候采用了内存对齐的方法,具体是:结构体在内存中的存放按单元进行存放,每个单元的大小取决于结构体中最大基本类型的大小

    对格式一:

    图1

    ​​​​因为所有成员中B成员类型最大(int型占用4个字节),故结构体Phone1在内存分布时以4字节为一个单元来存储每个成员。又因为A占用一个字节后,只剩下3字节了,放不下后面紧挨的成员B了,所以必须开辟一个新的单元来存放B,B刚好占满一个单元,接下来的成员C又必须再开辟一个新的单元来存放。这样,Phone1占用的字节数就是:3*4=12;

    同理对于格式二,

    图2

    A后面还有三个字节,足够存放C,所以C就放在了A的后面,然后只剩下一个字节了,不够存放后面的B,于是又开辟一个新单元存放B。这样,Phone2占用的内存字节就为2*4=8。

    对于格式三: 

     图3

    ​上面结构体中,最大数据类型是char,占一个字节,因此它的一个存储单元就是1个字节。sizeof(Phone3) =1 + 2 + 4 = 7, 其大小正好是结构体中各成员所占内存空间之和,这种情况也是最节省存储空间的。

    对于格式四:

    图4

    ​Phone4中最大的数据类型是double,占8个字节,因此它的一个存储单元就是8个字节。由上图可知sizeof(Phone4)=4*8=32。

    综上所述,格式一和格式四是非常浪费存储空间的,应该尽力避免;格式三对存储空间的利用率是最高的;格式二存储空间的利用率居中。作为一个优秀的程序员,应该深入掌握这些写法的差异性,以便视情况选用不同的写法。

    展开全文
  • 从结构体存储的首地址开始,每一个元素放置到内存中时,它都会认为内存是以它自己的大小来划分的,因此元素放置的位置一定会在自己宽度的整数倍上开始(以结构体变量首地址为0计算)。 原则2:在经过第一...

    结构体中元素占用字节大小,不能简单按照单独字节大小来计算,要进行整体分析得出结果


    原则1:结构体中元素是按照定义顺序一个一个放到内存中去的,但并不是紧密排列的。从结构体存储的首地址开始,每一个元素放置到内存中时,它都会认为内存是以它自己的大小来划分的,因此元素放置的位置一定会在自己宽度的整数倍上开始(以结构体变量首地址为0计算)。



    原则2:在经过第一原则分析后,检查计算出的存储单元是否为所有元素中最宽的元素的长度的整数倍,是,则结束;若不是,则补齐为它的整数倍。


    展开全文
  • 文章目录如何使用sizeof计算结构体所占内存大小前言一、各类型变量在不同运行环境中所占内存大小总结二、正文 前言 本博文用于记录学习过程中遇到的难点知识的总结,可能涉及到许多专业内容的非专业表述。请自动忽略...
  • 结构体所占内存的字节数如何计算?

    千次阅读 多人点赞 2019-08-22 21:43:23
    处理器的对齐要求,可能会在较小的成员后加入补位,从而导致结构体实际所占内存的 字节数比我们想象的多出一些字节。 下面从4个方面进行阐述: (1)结构体只包含基本数据类型; (2)结构体含有复合...
  • 三、结构体变量内存分配 四、结构体变量的初始化 五、结构体变量的引用 一、结构体类型定义 结构体是一种构造数据类型,可以把不同类型的数据整合在一起,每一个数据都称为该结构体类型的成员。使用结构体时,...
  • C语言中结构体所占内存空间

    万次阅读 多人点赞 2018-10-14 19:17:10
    结构体定义完成前,还会进行如下判断: 当前结构体的总大小是否为其最宽成员所占内存大小的整数倍,如果不是的话还要再将其填充成为整数倍。这也就是perInfo2的大小是 32 而不是 30 的原因了。 Tips perInfo2中...
  • C++ 类和结构体所占内存大小

    千次阅读 2017-11-29 18:26:17
    所占内存的大小是由成员变量(静态变量除外)决定的,成员函数(这是笼统的说,后面会细说)是不计算在内的。 摘抄部分: 成员函数还是以一般的函数一样的存在。a.fun()是通过fun(a.this)来调用的。所谓成员函数...
  • C++中 类 和 结构体所占内存大小

    千次阅读 2017-02-16 09:39:52
    所占内存的大小是由成员变量(静态变量除外)决定的,成员函数(这是笼统的说,后面会细说)是不计算在内的。 摘抄部分: 成员函数还是以一般的函数一样的存在。a.fun()是通过fun(a.this)来调用的。所谓成员函数...
  • 一个结构体变量定义完之后,其在内存中的存储并不等于其包含元素的宽度之和。 例一: #include using namespace std; struct X { char a; int b; double c; }S1;
  • 结构体 数组是用于保存一组相同类型数据的, 而结构体是用于保存一组不同类型数组的 在使用结构体之前必须先定义结构体类型, 因为C语言不知道你的...结构体变量占用存储空间大小 struct Person{ int age; // 4 第
  • 具体的理论内容 神马是内存对齐以及为何要...这里对如何计算结构体所占内存大小做出总结 1、首先要弄清成员变量有效对齐方式的值 N 这里面有四个概念值: 1)数据类型自身的对齐值:就是上面交代的基本数据类型的自
  • C语言 | 结构体变量

    2021-04-29 08:41:58
    花括号内是该结构体所包括的子项,称为结构体的成员,对各个成员都应该进行类型声明。 即 类型名 成员名 成员表列也称为域表,每一个成员是结构体中的一个域,成员命名规则与变量名相同。 C语言如何定义结构
  • 在C语言中我们如何去运用结构体变量和结构的变量的指针作为函数的参数呢,其实我们对于结构体的变量是有一定的了解的,他们就是将一个结构体变量的值传递给另外一个函数,那么这种有三种方法,希望大家都能够了解...
  • #include <stdio.h> struct Num{ int a; float b; double c; }; int main(int argc,char *argv[]){ struct Num n; printf("sizeof(n)=%d\n",sizeof(n)); printf("&... printf("&...
  • 一个结构体变量定义完之后,其在内存中的存储并不等于其包含元素的宽度之和。 1.有两个原则: 原则一:结构体中元素是按照定义顺序一个一个放到内存中去的,但并不是紧密排列的。从结构体存储的首地址开始,每一个...
  • 结构体变量后边带的冒号:

    千次阅读 2014-06-18 14:42:38
    C语言允许在一个结构体中以位为单位来指定其成员所占内存长度,这种以位为单位的成员成为“位段”或位域,利用位段能够用较少的位数存储数据。如: struct packed_data (该例子假定int占2个字节,因为在c语言中...
  • C语言结构体变量私有化

    千次阅读 2019-04-03 20:26:03
    C语言结构体定义中的变量默认是公有(Public)属性,如果实现成员变量的私有(Private)化? 有人说可以通过设置private使成员变量私有化,但如果这样做那就真的“私有化”了。因为一般结构体都没有成员函数(尽管...
  • C/C++结构体所占内存的问题

    千次阅读 2011-08-18 16:24:22
    1) 结构体变量的首地址能够被其最宽基本类型成员的大小整除; 2) 结构体每个成员相对于结构体首地址的偏移量(of f set)都是成员大小的整数倍,如有需要编译器会在成员之间加上填充字节(internal adding); ...
  • 在用sizeof运算符求算某结构体所占空间时,并不是简单地将结构体中所有元素各自的空间相加,这里涉及到内存字节对齐的问题。从理论上讲,对于任何 变量的访问都可以从任何地址开始访问,但是事实上不是如此,实际...
  • C++指向结构体变量的指针

    千次阅读 2017-04-05 19:42:33
    在定义了结构体变量后,系统会为之分配内存单元。例如student1和student2在内存中各63个字节(4+20+1+4+4+30=63)。 2) 在声明类型的同时定义变量。例如: 复制 纯文本 复制 struct ...
  • 我们都知道C语言中变量的类型决定了变量存储占用的空间。当我们要使用一个变量保存年龄时可以将其声明为int类型,当我们要使用一个变量保存某一科目的考试成绩时可以将其声明为float。 那么,当我们要做一个学生信息...
  • 结构体字节对齐在用sizeof运算符求算某结构体所占空间时,并不是简单地将结构体中所有元素各自的空间相加,这里涉及到内存字节对齐的问题。从理论上讲,对于任何 变量的访问都可以从任何地址开始访问,但是事实上...
  • 传送门
  • 转载自:http://blog.csdn.net/grantxx/article/details/7577730 转载自:...一个结构体变量定义完之后,其在内存中的存储并不等于其包含元素的宽度之和。 例一:
  •  使用结构体变量作为函数的实参时,采用的是值传递,会将结构体变量所占内存单元的内容全部顺序传递给形参,形参必须是同类型的结构体变量 demo: 1 # include <stdio.h> 2 # include <stdlib.h> ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,376
精华内容 4,550
关键字:

结构体变量所占的内存单元