程序运行时，结构体的内存分配，大讨论。。。

 十分疑惑：  
                定义一个结构体  
                typedef   struct   example  
                                          {  
                                              int   a;  
                                              int   b;  
                                              struct   example   *next;  
                                            }*link;  
                  link   a;                                                                         ----------(1)  
                  a=(link)malloc(sizeof(link));                             ----------(2)  
                  a=(link)malloc(sizeof(*a));                                 ----------(3)  
                   
    问题：  
              1。当程序执行到（1）时，内存的分配是怎样的？是不是已经为   a,b都分配了内存  
              2。（2）（3）有和区别？  
              3。当程序在编译时，结构体变量的内存分配细节是怎样的？   

 

1 楼Againstwind（逆风飞扬）

（1）的时候应该指给Link   a分配了指针所用的空间吧！  
  （3）这种用法对吗？我很疑惑！Top

2 楼zhouzhaohan（）

1)在栈里给分配一个指针类型大小的空间，里面放的是a的值。  
  2）要从堆里分配一块空间，大小是指针类型大小(可能实际上不止这么多)。a为这块空间的首地址。  
  3）要从堆里分配一块空间，大小是sizeof(struct   example)(可能实际上不止这么多)。a为这块空间的首地址。  
  4)2)中分配的空间的首地址对了，内存泄漏。Top

3 楼zhouzhaohan（）

4)2)中分配的空间的首地址丢了，内存泄漏。  
  Top

4 楼windcsn（向所有的朋友学习！）

1，这个时候只分配指针的内存，而指针指向未定，也就是你想要给分配的结构内的内容没有分配  
  2，没有什么区别，都是取得结构的大小，一个用结构的名称，另一个用指向结构的指针的解除引用  
  3，编译的时候和内存分配有什么关系？我想最终得到的内存为变量ab的内存和一个指针的内存Top

5 楼sunriselx（）

（1）link声明为指针，所以a是指针，所以a->a,a->b没有分配内存  
  （2）这种用法是错的，只分配了4byte内存，sizeof(a)等于sizeof(struct   example*),应该a=(link)malloc(sizeof(struct   example))  
  （3）没问题，编译器会把sizeof(*a）替换为sizeof(struct   example);Top

6 楼chenxihui2003（晨曦）

1.到1时，指针所示赋所指空间，故没有为工a,b分配内存。  
   
  2.（2）分配的为一个指针大小的空间，四字节；  
      （3）分配的为此结构体所占用的大小空间，十二字节。  
   
  3.结构体动态分配时是按其内部所有变量所占用空间的总和来分配空间的。Top

7 楼chinajiji（菜鸟叽叽）

1。当程序执行到（1）时，内存的分配是怎样的？是不是已经为   a,b都分配了内存  
  link   a;   相当于:struct   example*   a;即定义了一个指向struct   example的指针,a->a,a->b没有分配内存.指针变量存放在stack中,而不是heap中.  
   
  2。（2）（3）有和区别？  
   
  a=(link)malloc(sizeof(link));                             ----------(2)  
  相当于:  
  a   =   (struct   example*)malloc(sizeof(struct   example*));  
  即:  
  a   =   (struct   example*)malloc(4);  
  如果在32机器上,如vc6.0上,则:sizeof(struct   example*)   ==   4;  
   
  我觉得:  
  a=(link)malloc(sizeof(link));                             ----------(2)  
  在内存分配上有问题,因为指针a所指的内存只分配了4字节(如果sizeof(struct   example*)   ==   4的话),而sizeof(struct   example)   =   2   *   sizeof(int)   +   sizeof(struct   example   *)   ==   2   *   4   +   4   =   12(不考虑位对齐);  
  如果改成这样:  
  link*   a   =   (link*)malloc(sizeof(link));                              
  就对了.此时,a是一个二重指针;  
  而下面这个语句:  
  a=(link)malloc(sizeof(*a));                                 ----------(3)  
  等价于:  
  a   =   (struct   example*)malloc(sizeof(struct   example));  
  a   是一个指向   struct   example的一级指针,sizeof(struct   example)   ==   12(如上述);  
   
  3。当程序在编译时，结构体变量的内存分配细节是怎样的？  
  我不知道你想问什么?Top

8 楼windcsn（向所有的朋友学习！）

惭愧，看花了眼Top

9 楼zhouzhaohan（）

你的最后一个问题在网上搜struct   align   padding就可以找到很多这方面的讨论。

 

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

结构体的内存分配查看

 

#include <stdio.h>
typedef struct
{
        int a;
        int b;
        char c;
        char d;
        double e;
        float f;
        int g;
}Vari;
int main()
{
  
    Vari first;
  /* 
    first.a=1;
    first.b=2;
    first.c='a';
    first.d='a';
    first.e=1.0;
    first.f=1.0;
    first.g=1;
   */ 
   int m=sizeof(first);//or sizeof(Vari)
  
    printf("the struct size: %d/n",m);
    printf("the addr for component int a:  %x and size:%d/n",&first.a,sizeof(first.a));
    printf("the addr for component int b:  %x and size:%d/n",&first.b,sizeof(first.b));
    printf("the addr for component char c: %x and size:%d/n",&first.c,sizeof(first.c));
    printf("the addr for component char d: %x and size:%d/n",&first.d,sizeof(first.d));
    printf("the addr for component double e: %x and size:%d/n",&first.e,sizeof(first.e));
    printf("the addr for component float f: %x and size:%d/n",&first.f,sizeof(first.f));
    printf("the addr for component int g: %x and size:%d/n",&first.g,sizeof(first.g));
   
    getchar();
}
/*
运行结果：
the struct size: 32
the addr for component int a:    22ff50   and size:4
the addr for component int b:    22ff54  and size:4
the addr for component char c:   22ff58  and size:1
the addr for component char d:   22ff59  and size:1
the addr for component double e:  22ff60  and size:8
the addr for component float f:  22ff68  and size:4
the addr for component int g:  22ff6c  and size:4
*/
有个问题一直迷惑：

为什么各个结构体的组件的大小之和不等于结构体的大小？结构体的各个组件在内存中是顺序分配空间的，但是整个结构体多出来的空间在哪里？

请高手指教。。。。。。。。感激不尽。。。。。。。。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

    网友评论        

内容：	这是个字节对其的问题
本站网友评论于：2007-11-14 20:04:30 （121.35.126.★）
内容：	能具体一点吗？ 可是整个结构体的大小 与各个组件大小之和不等啊。。。
zclmoon 评论于：2007-11-14 21:19:59 （60.175.122.★）

 

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

C/C++ 语言中结构体的内存分配

当未用 #pragma 指令指定编译器的对齐位数时，结构体按最长宽度的数据成员的宽度对齐；当使用了 #pragma 指令指定编译器的对齐位数时，结构体按最长宽度的数据成员的宽度和 #pragma 指令指定的位数中的较小值对齐。

    #pragma 指令格式如下所示：
        #pragma pack(4)     // 或者 #pragma pack(push, 4)

    举例如下：（机器字长为 32 位）
    struct
    {
        char a;
    }test;
    printf("%d/n", sizeof test);
打印出来的结果为 1；
    struct
    {
        char a;
        short b;
        char c;
    }test;
    printf("%d/n", sizeof test);
打印出来的结果为 6；
    struct
    {
        char a;
        int b;
        char c;
    }test;
    printf("%d/n", sizeof test);
打印出来的结果为 12；
    struct
    {
        char a;
        double b;
        char c;
    }test;
    printf("%d/n", sizeof test);
打印出来的结果为 24；
    #pragma pack(4)
    struct
    {
        char a;
        double b;
        char c;
    }test;
    printf("%d/n", sizeof test);
打印出来的结果为 16；

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ 结构体的内存分配大小 ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

当结构体中最长宽度的数据成员的宽度小于机器字长时，按该成员宽度对齐；

            当最长宽度的数据成员的宽度大于或等于机器字长时，按机器字长对齐。

            举例如下：（机器字长为 32 位）   

            struct    {      

                   char a;   

            }test;   

             printf("%d/n", sizeof test);

            打印出来的结果为 1；   

            struct    {   

                     char a;       

                      short int b;       

                      char c;   

           }test;   

           printf("%d/n", sizeof test);

           打印出来的结果为 6；   

           struct    {       

                       char a;       

                       int b;       

                        char c;  

                      }test;  

            printf("%d/n", sizeof test);打印出来的结果为 12；   

                       struct    {       

                                  char a;      

                                  double b;      

                                char c;   

                                     }test;   

                         printf("%d/n", sizeof test);

                         打印出来的结果为 16；