C语言中的柔性数组 C语言结构体中char[0]和char[1]的用法
原创C语言中的柔性数组 C语言结构体中char[0]和char[1]的用法
原创
1.写在前面
我在进行Linux 64位驱动程序兼容32位应用程序的适配过程中，深深的感觉指针操作带来的麻烦，特别是应用层的32位指针传到内核层后，指针大小变成64位，需要进行频繁的大小调整，及其难受。等我快完成所有工作的时候，听一位同事说可以使用char[0]用法来代替指针，我差点一口老血喷出来。“你咋不早说…”。接下来从网上各种google，发现了这种用法的巧妙，特写下此篇文章，以做记录。 （PS：还是要感谢我那位同事YYL，让我又get到一个技能^_^）
在结构体最后加char[0]或char[1]的用法是GNU C的扩展，在ISO/IEC 9899-1999里面，这么写是非法的。这种用法在C99中叫做?柔性数组。柔性数组成员前面必须至少有一个其它类型成员。包含柔性数组成员的结构要用malloc进行动态内存分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
2.引用这种用法的目的
主要是为了方便管理内存缓冲区，如果你直接使用指针而不使用数组，那么，你在分配内存缓冲区时，就必须分配结构体一次，然后再分配结构体内的指针一次，（而此时分配的内存已经与结构体的内存不连续了，所以要分别管理即申请和释放）而如果使用数组，那么只需要一次就可以全部分配出来，反过来，释放时也是一样，使用数组，一次释放，使用指针，得先释放结构体内的指针，再释放结构体。还不能颠倒次序。
其实就是分配一段连续的的内存，减少内存的碎片化。
3.用法
复制
1 2 3 4 5 6 7 | struct Msg { ... // 其它成员 ... // 其它成员 int nLen; // 一般char data[0]的前面会加一个长度nLen表示data的大小 char data[0]; // char[0]或char[1]必须放在最后 }; |
|---|
我们要知道的一点就是：char data[0] 这个数组是没有元素的，它的地址紧跟着nLen后的地址，如果分配的内存大于结构体的实际大小，那么大出来的那部分就是data的内容。
实际使用时，一般这样用
复制
1 2 3 | int dataBytes = 10; // 此处指定data的数据大小 struct Msg *p = (struct Msg *)malloc(sizeof(struct Msg) + dataBytes); // 动态分配 p->nLen = dataBytes; // 把长度赋值给nLen，以方便其它部分使用此结构体 |
|---|
如果还不明白，撸一串代码，一看便知：
复制
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 | // test.c #include <stdio.h> #include <string.h> typedef struct body1 { int a; int b; }__attribute ((packed)) BODY1; //__attribute ((packed))是强制不进行字节对齐 typedef struct body2 { int len; char *data; }__attribute ((packed)) BODY2; typedef struct body3 { int len; char data[0]; }__attribute ((packed)) BODY3; typedef struct body4 { int len; char data[1]; }__attribute ((packed)) BODY4; int main() { BODY1 b1; BODY2 b2; BODY3 b3; BODY4 b4; memset(&b1, 0, sizeof(BODY1)); memset(&b2, 0, sizeof(BODY2)); memset(&b3, 0, sizeof(BODY3)); memset(&b4, 0, sizeof(BODY4)); printf("sizeof(b1) = %ld\n", sizeof(b1)); printf("sizeof(b2) = %ld\n", sizeof(b2)); printf("sizeof(b3) = %ld\n", sizeof(b3)); printf("sizeof(b4) = %ld\n", sizeof(b4)); printf(" b2 addr = %p\n", &b2); printf("b2.data addr = %p\n", b2.data); printf(" b3 addr = %p\n", &b3); printf("b3.data addr = %p\n", b3.data); printf(" b4 addr = %p\n", &b4); printf("b4.data addr = %p\n", b4.data); return 0; } |
|---|
程序是在64位系统下编译，运行结果如下:
复制
1 2 3 4 5 6 7 8 9 10 | sizeof(b1) = 8 sizeof(b2) = 12 sizeof(b3) = 4 sizeof(b4) = 5 b2 addr = 0x7ffded4f3633 b2.data addr = (nil) b3 addr = 0x7ffded4f363f b3.data addr = 0x7ffded4f3643 b4 addr = 0x7ffded4f3643 b4.data addr = 0x7ffded4f3647 |
|---|
从上面的结果可以看出：
- char data[0]是不占用任何空间的，而char *data占用了一个指针变量的大小，千万不要把char data[0]当做一个指针，它其实是一个偏移量，这个偏移量指向结构体后紧挨着的空间。
- char[1]是占用空间的，如果没加强制不进行字节对齐，则结构体的大小会是8。char[0]和char[1]的作用是相同的。
- b3的data地址，是b3结构体开始的地址加上len所占用的4字节的地址，b4也是一样。
4.用指针和char[0]的区别
- 结构体中使用指针：创建时，系统先为结构体分配内存，再分配指针指向的data的内存。两块内存不连续。释放的时候，先释放指针指向的内存，再释放结构体内存。
- 结构体中使用char[0]：创建时，系统一起为其分配结构体的内存和data的内存，两块内存是连续的（更确切的说是一块内存）。释放的时候，一次性释放。
============================================================
在日常的编程中，有时候需要在结构体中存放一个长度动态的字符串，一般的做法，是在结构体中定义一个指针成员，这个指针成员指向该字符串所在的动态内存空间，例如：
123456 | typedef?struct?test{int?a;double?b;char?*p;}; |
|---|
p指向字符串。这种方法造成字符串与结构体是分离的，不利于操作。如果把字符串跟结构体直接连在一起，不是更好吗？于是，可以把代码修改为这样：
123 | char?a[] =?"hello world";test *stpTest = (test *)malloc(sizeof(test) +?strlen( a ) + 1 );strcpy(stpTest + 1, a ); |
|---|
这样一来，( char* )(stpTest + 1 )就是字符串"hello world"的地址了。这时候p成了多余的东西，可以去掉。但是，又产生了另外一个问题：老是使用( char* )((stpTest + 1 )不方便。如果能够找出一种方法，既能直接引用该字符串，又不占用结构体的空间，就完美了，符合这种条件的代码结构应该是一个非对象的符号地址，在结构体的尾部放置一个0长度的数组是一个绝妙的解决方案。不过，C/C++标准规定不能定义长度为0的数组，因此，有些编译器就把0长度的数组成员作为自己的非标准扩展。
在讲述柔性数组成员之前，首先要介绍一下不完整类型(incomplete type)。不完整类型是这样一种类型，它缺乏足够的信息例如长度去描述一个完整的对象，
它的出现反映了C程序员对精炼代码的极致追求，这种代码结构产生于对动态结构体的需求。
鉴于这种代码结构所产生的重要作用，C99甚至把它收入了标准中。C99使用不完整类型实现柔性数组成员，在C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做柔性数组(flexible array)成员(也叫伸缩性数组成员)，但结构中的柔性数组成员前面必须至少一个其他成员。柔性数组成员允许结构中包含一个大小可变的数组。柔性数组成员只作为一个符号地址存在，而且必须是结构体的最后一个成员，sizeof 返回的这种结构大小不包括柔性数组的内存。柔性数组成员不仅可以用于字符数组，还可以是元素为其它类型的数组。包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。柔性数组的使用请看下面的例子：
123456 | typedef?struct?test{int?a;double?b;char?c[0];}; |
|---|
有些编译器会报错无法编译可以改成：
123456 | typedef?struct?test{int?a;double?b;char?c[];}; |
|---|
通过如下表达式给结构体分配内存：
1 | test *stpTest = (test *)malloc(sizeof(test)+100*sizeof(char)); |
|---|
c就是一个柔性数组成员，如果把stpTest指向的动态分配内存看作一个整体，c就是一个长度可以动态变化的结构体成员，柔性一词来源于此。c的长度为0，因此它不占用test的空间，同时stpTest->c就是“hello world”的首地址，不需要再使用( char * )( stpTest + 1 )这么丑陋的代码了。那个0个元素的数组没有占用空间，而后我们可以进行变长操作了。这样我们为结构体指针c分配了一块内存。用stpTest->c[n]就能简单地访问可变长元素。
当然，上面既然用malloc 函数分配了内存，肯定就需要用free 函数来释放内存：
1 | free(stpTest); |
|---|
应当尽量使用标准形式，在非C99的场合，可以使用指针方法。需要说明的是：C89不支持这种东西，C99把它作为一种特例加入了标准。但是，C99所支持的是incomplete type，而不是zero array，形同int a[0];这种形式是非法的，C99 支持的形式是形同int a[];只不过有些编译器把int a[0];作为非标准扩展来支持，而且在C99 发布之前已经有了这种非标准扩展了，C99 发布之后，有些编译器把两者合而为一了。
??????????由于数组没有元素，该数组在该结构体中分配占用空间，所以sizeof(struct Mydata) = 4。 ?????????malloc申请的是14个字节的连续空间，它返回一个指针指向这14个字节，强制转换成struct INFO的时候，前面4个字节被认为是Mydata结构，后面的部分拷贝了“123456789”的内容。
3、实际当中的用法
???? 在实际程序中，数据的长度很多是未知的，这样通过变长的数组可以方便的节省空间。对指针操作，方便数据类型的转换。测试程序如下：
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <stdint.h>
5
6 typedef struct
7 {
8 int data_len;
9 char data[0];
10 }buff_st_1;
11
12 typedef struct
13 {
14 int data_len;
15 char *data;
16 }buff_st_2;
17
18 typedef struct
19 {
20 int data_len;
21 char data[];
22 }buff_st_3;
23
24 typedef struct
25 {
26 uint32_t id;
27 uint32_t age;
28 }student_st;
29
30
31 void print_stu(const student_st *stu)
32 {
33 printf("id:%u,age:%u\n", stu->id, stu->age);
34 }
35
36 int main()
37 {
38 student_st *stu = (student_st *)malloc(sizeof(student_st));
39 stu->id = 100;
40 stu->age = 23;
41
42 student_st *tmp = NULL;
43
44 buff_st_1 *buff1 = (buff_st_1 *)malloc(sizeof(buff_st_1) + sizeof(student_st));
45 buff1->data_len = sizeof(student_st);
46 memcpy(buff1->data, stu, buff1->data_len);
47 printf("buff1 address:%p,buff1->data_len address:%p,buff1->data address:%p\n",
48 buff1, &(buff1->data_len), buff1->data);
49
50 tmp = (student_st*)buff1->data;
51 print_stu(tmp);
52
53 buff_st_2 *buff2 = (buff_st_2 *)malloc(sizeof(buff_st_2));
54 buff2->data_len = sizeof(student_st);
55 buff2->data = (char *)malloc(buff2->data_len);
56 memcpy(buff2->data, stu, buff2->data_len);
57 printf("buff2 address:%p,buff2->data_len address:%p,buff2->data address:%p\n",
58 buff2, &(buff2->data_len), buff2->data);
59
60 tmp = (student_st *)buff2->data;
61 print_stu(tmp);
62
63 buff_st_3 *buff3 = (buff_st_3 *)malloc(sizeof(buff_st_3) + sizeof(student_st));
64 buff3->data_len = sizeof(student_st);
65 memcpy(buff3->data, stu, buff3->data_len);
66 printf("buff3 address:%p,buff3->data_len address:%p,buff3->data address:%p\n",
67 buff3, &(buff3->data_len), buff3->data);
68
69 tmp = (student_st*)buff1->data;
70 print_stu(tmp);
71
72 free(buff1);
73
74 free(buff2->data);
75 free(buff2);
76
77 free(buff3);
78 free(stu);
79 return 0;
80 }? 采用char *data，需要进行二次分配，操作比较麻烦，很容易造成内存泄漏。而直接采用变长的数组，只需要分配一次，然后进行取值即可以。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。