C 语言变长数组 struct 中 char data[0] 的用法

1、结构体内存布局（padding）

为了让CPU能够更舒服地访问到变量，struct中的各成员变量的存储地址有一套对齐的机制。这个机制概括起来有两点：第一，每个成员变量的首地址，必须是它的类型的对齐值的整数倍，如果不满足，它与前一个成员变量之间要填充(padding)一些无意义的字节来满足；第二，整个struct的大小，必须是该struct中所有成员的类型中对齐值最大者的整数倍，如果不满足，在最后一个成员后面填充。

The following typical alignments are valid for compilers from Microsoft, Borland, and GNU when compiling for 32-bit x86:

• A char (one byte) will be 1-byte aligned.
• A short (two bytes) will be 2-byte aligned.
• An int (four bytes) will be 4-byte aligned.
• A float (four bytes) will be 4-byte aligned.
• A double (eight bytes) will be 8-byte aligned on Windows and 4-byte aligned on Linux.
• A long double (twelve bytes) will be 4-byte aligned on Linux.
• Any pointer (four bytes) will be 4-byte aligned on Linux. (eg: char*, int*)

The only notable difference in alignment for a 64-bit linux system when compared to a 32 bit is:

• A double (eight bytes) will be 8-byte aligned.
• A long double (Sixteen bytes) will be 16-byte aligned.
• Any pointer (eight bytes) will be 8-byte aligned.

案例一：

#include <stdio.h>#include <stdlib.h>#include <string.h>struct s1{     char ch,*ptr;     union     {         short a,b;         unsigned int c:2,d:1;     };     struct s1 *next;};int main(){              printf("%d\n",sizeof(struct s1));        return 0;}

struct s1{       char ch,*ptr;    //ch和*ptr各占4bit,共8bit       union   //按照最长的计算,union占4bit      {            short a,b;            unsigned int c:2,d:1;       }       struct s1 *next;  //4bit}

案例二：

struct s2{char ch;char *ptr;union {short a,b;unsigned int c:2,d:1;};int x;double y;struct s2 *next;};

struct s2{char ch;char *ptr; //ch和*ptr各占4bit,共8bitunion {   //按照最长的计算,union占4bitshort a,b;unsigned int c:2,d:1;};int x; //int占4bitdouble y;//double占8bitstruct s2 *next;//padding 到8bit};//32 bit

案例三：

struct s3{char ch;char *ptr;union {short a,b;unsigned int c:2,d:1;};int x;double y;struct s2 p;};

struct s3{char ch;char *ptr; //ch和*ptr各占4bit,共8bitunion {   //按照最长的计算,union占4bitshort a,b;unsigned int c:2,d:1;};int x; //int占4bitdouble y;//double占8bitstruct s2 p;//32};//24+32=56 bit

变长数组

摘要：在实际的编程中，我们经常需要使用变长数组，但是C语言并不支持变长的数组。此时，我们可以使用结构体的方法实现C语言变长数组。

struct MyData {   int nLen;   char data[0];}; 

在结构中，data是一个数组名；但该数组没有元素；该数组的真实地址紧随结构体MyData之后，而这个地址就是结构体后面数据的地址（如果给这个结构体分配的内容大于这个结构体实际大小，后面多余的部分就是这个data的内容）；这种声明方法可以巧妙的实现C语言里的数组扩展。
实际用时采取这样：
struct MyData *p = (struct MyData *)malloc(sizeof(struct MyData )+strlen(str))
这样就可以通过p->data 来操作这个str。

这样就可以通过p->data 来操作这个str。

程序实例：

struct MyData {int nLen;char data[0];};int main(){ int nLen = 10;char str[10] = "123456789";cout << "Size of MyData: " <<sizeof(MyData) << endl;MyData *myData = (MyData*)malloc(sizeof(MyData) +10);memcpy(myData->data, str, 10);cout << "myData's Data is: " << myData->data << endl;free(myData);return 0;}

输出：

Size of MyData:
   4
myData"s Data is: 123456789

以下是摘自：http://bbs.chinaunix.net/thread-1455677-1-1.html

我想举一个自己最近在项目中犯的错误来说明要踏踏实实做人，不要做装B青年 
在代码中，我需要在一个library和一个daemon之间通过socket传送数据包，包的格式定义如下（为了简化，我就用最简单的数据类型举例）：

1. typedef struct {
   
2.         int head;
   
3.         int size; //指明整个包的长度
   
4.         char reply;
   
5.         char data[0];
   
6. } packet;
   
7. 
   
8. packet*  cmd = malloc (sizeof(packet) + 20);
   
9. memcpy (packet->data, some_data, 20);

复制代码

daemon将上面分配的cmd包发送给library，library接收到包后，需要将data字段中的数据取出来。size指明了整个包的长度，但没有字段指明数据的长度。我需要这么一个指明数据长度的字段吗？作为一个装B青年，我认为当然不需要，于是我这样来计算数据的长度：

1. #define offsetof(type, element) ((int)&((type *)0)->element)
   
2. static inline size_t packet_data_len(packet* cmd) {
   
3.     assert(cmd);
   
4.     return cmd->size - offsetof(packet, data);
   
5. }
   
6. 
   
7. memcpy (buffer_to_receive_data, cmd->data, packet_data_len (cmd));

复制代码

于是乎，这段程序成功的给我带来了无数的bug，莫名奇妙的segfault，奇怪的数据错误，还是有部分时间的正常工作。当然，最终我还是找到了问题：
sizeof (packet) == 12;
这是合理的，char reply被padding成了4个字节，而char data[0]字节为0。
但，offsetof(packet, data) == 9，在计算偏移时，char reply为一个字节，没有padding。
所以packet_data_len每次都会返回比真实的数据多3个字节 ……

最后我还是老老实实加了个data_len字段指明数据的长度。