C语言中长度为0的数组

转载：/article/8440692.html

C语言中长度为0的数组

前面在看Xen的源码时，遇到了一段代码，如下所示：





注意上面最后一行的代码，这里定义了一个长度为的数组，这种用法可以吗？为什么可以使用长度为0 的数组？长度为的数组到底怎么使用？……这篇文章主要针对该问题进行简单的讲解。废话不多说了，现在就开始。

长度为的数组在标准c和c++中是不允许的，如果使用长度为的数组，编译时会产生错误，提示数组长度不能为。但在GNUc中，这种用法却是合法的。它的最典型的用法就是位于数组中的最后一项，如上面所示，这样做主要是为了方便内存缓冲区的管理。如果你将上面的长度为的数组换为指针，那么在分配内存时，需采用两步：首先，需为结构体分配一块内存空间；其次再为结构体中的成员变量分配内存空间。这样两次分配的内存是不连续的，需要分别对其进行管理。当使用长度为的数组时，则是采用一次分配的原则，一次性将所需的内存全部分配给它。相反，释放时也是一样的。

对于长度为的数组，在gcc手册中，有如下一段代码片段：

struct line {

int length;

char contents[0];

};

struct line *thisline = (struct line *)malloc (sizeof (struct line) + this_length);

thisline->length = this_length;

这段代码的主要含义是定义了一个结构体，并对其进行初始化，上面结构体的第二个成员变量contents[0]事实上是不占内存空间的，因此整个结构体的长度sizeof(struct line)为4。当采用malloc为其申请内存空间时，如上所示，申请了一段长度为结构体长度加可变长度的内存空间给结构体类型的指针，这时contents就指向申请的可变长度的内存空间。由于是一次申请的，所以这段可变长度的内存空间和前面的结构体长度的内存空间是连续的。对于这段可变长度的内存空间，可以采用数组的方式对其进行访问。对于整个结构体，当不再使用时，可以使用free函数一次性对其进行释放，而不必像指针那样分别释放。

下面举例进行说明：

#include <stdio.h>

#include <stdlib.h>

#define LENGTH 10

struct test1

{

int a;

int *b;

}__attribute((packed));

struct test2

{

int a;

int b[0];

}__attribute((packed));

struct test3

{

int a;

int b[1];

}__attribute((packed));

int main()

{

struct test1 *var1;

struct test2 *var2;

struct test3 *var3;

int i;

printf("the length of struct test1:%d\n",sizeof(struct test1));

printf("the length of struct test2:%d\n",sizeof(struct test2));

printf("the length of struct test3:%d\n",sizeof(struct test3));

var1=(struct test1*)malloc(sizeof(struct test1));

var1->a=1;

var1->b=(int *)malloc(sizeof(int));

*var1->b=1;

printf("\nvar1->a=%d,*(var1->b)=%d\n",var1->a,*var1->b);

var2=(struct test2*)malloc(sizeof(struct test2)+sizeof(int)*LENGTH);

var2->a=2;

printf("\nvar2->a=%d\n",var2->a);

for(i=0;i<LENGTH;i++)

{

var2->b[i]=i;

printf("var2->b[i]=%d\t",var2->b[i]);

}

printf("\n\n");

var3=(struct test3*)malloc(sizeof(struct test3));

var3->a=3;

(var3->b)[0]=3;

printf("var3->a=%d,(var3->b)[0]=%d\n",var3->a,(var3->b)[0]);

free(var1->b);

free(var1);

free(var2);

free(var3);

}

这段程序的运行结果如下图所示：





从上面的结果可以看出：

l 长度为的数组并不占有内存空间，而指针方式需要占用内存空间。

l 对于长度为数组，在申请内存空间时，采用一次性分配的原则进行；对于包含指针的结构体，才申请空间时需分别进行，释放时也需分别释放。

l 对于长度为的数组的访问可采用数组方式进行。

摘自：/article/2577877.html

结构体中最后一个成员为[0]或[1]长度数组(柔性数组成员)的用法

分类： C/C++2014-04-20
16:23 1291人阅读 评论(0) 收藏 举报

结构体中最后一个成员为[0]长度数组的用法：这是个广泛使用的常见技巧，常用来构成缓冲区。比起指针，用空数组有这样的优势：(1)、不需要初始化，数组名直接就是所在的偏移；(2)、不占任何空间，指针需要占用int长度空间，空数组不占任何空间。“这个数组不占用任何内存”，意味着这样的结构节省空间；“该数组的内存地址就和它后面的元素地址相同”，意味着无需初始化，数组名就是后面元素的地址，直接就能当指针使用。

这样的写法最适合制作动态buffer，因为可以这样分配空间malloc(sizeof(structXXX) + buff_len); 直接就把buffer的结构体和缓冲区一块分配了。用起来也非常方便，因为现在空数组其实变成了buff_len长度的数组了。这样的好处是：(1)、一次分配解决问题，省了不少麻烦。为了防止内存泄露，如果是分两次分配(结构体和缓冲区)，那么要是第二次malloc失败了，必须回滚释放第一个分配的结构体。这样带来了编码麻烦。其次，分配了第二个缓冲区以后，如果结构里面用的是指针，还要为这个指针赋值。同样，在free这个buffer的时候，用指针也要两次free。如果用空数组，所有问题一次解决。(2)、小内存的管理是非常困难的，如果用指针，这个buffer的struct部分就是小内存了，在系统内存在多了势必严重影响内存管理的性能。要是用空数组把struct和实际数据缓冲区一次分配大块问题，就没有这个问题。如此看来，用空数组既简化编码，又解决了小内存碎片问题提高了性能。

结构体最后使用0或1长度数组的原因：主要是为了方便的管理内存缓冲区(其实就是分配一段连续的内存，减少内存的碎片化)，如果直接使用指针而不使用数组，那么，在分配内存缓冲区时，就必须分配结构体一次，然后再分配结构体内的指针一次，(而此时分配的内存已经与结构体的内存不连续了，所有要分别管理即申请和释放)而如果使用数组，那么只需要一次就可以全部分配出来，反过来，释放时也是一样，使用数组，一次释放。使用指针，得先释放结构体内的指针，再释放结构体，还不能颠倒顺序。

结构体中最后一个成员为[1]长度数组的用法：与长度为[0]数组的用法相同，改写为[1]是出于可移植性的考虑。有些编译器不支持[0]数组，可将其改成[]或[1].

不完整类型(incomplete type)：它缺乏足够的信息例如长度去描述一个完整的对象。(1)、前向声明就是一种常用的不完整类型， class base; struct test; base和test只给出了声明，没有给出定义。不完整类型必须通过某种方式补充完整，才能使用它们进行实例化，否则只能用于定义指针或引用，否则只能用于指针或引用，因为此时实例化的是指针或引用本身，不是base或test对象。(2)、一个未知长度的数组也属于不完整类型：extern
int a[]; extern不能去掉，因为数组的长度未知，不能作为定义出现。不完整类型的数组可以通过几种方式补充完整才能使用，大括号形式的初始化就是其中一种方式：int a[] = {10, 20};

柔性数组成员(flexible array member)：也叫收缩性数组成员，这种代码结构产生于对动态结构体的需求。C99使用不完整类型实现柔性数组成员，在C99中，结构中的最后一个元素允许是未知大小的数组，这就叫柔性数组成员。但结构中的柔性数组成员前面必须至少一个其它成员。柔性数组成员允许结构中包含一个大小可变的数组。柔性数组成员只作为一个符号地址存在，而且必须是结构体的最后一个成员，sizefo返回的这种结构大小不包括柔性数组的内存。柔性数组成员不仅可以用于字符数组，还可以是元素为其它类型的数组。包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

C/C++标准规定不能定义长度为0的数组，因此，有些编译器就把0长度的数组成员作为自己的非标准扩展。

示例代码：

[cpp] view
plaincopy





#include <iostream>

using namespace std;

typedef struct _FlexibleArray

{

char ch;

int arr[0];//int arr[];//int arr[1];

}FlexibleArray;

int main()

{

cout<<sizeof(FlexibleArray)<<endl;

const int LENGTH = 10;

FlexibleArray* flexibleArray = (FlexibleArray*)new char[sizeof(FlexibleArray) + LENGTH * sizeof(int)];

for (int i = 0; i < LENGTH; i ++) {

flexibleArray->arr[i] = i * i;

}

for (int i = 0; i < LENGTH; i ++) {

cout<<flexibleArray->arr[i]<<endl;

}

delete [] flexibleArray;

return 0;

}