http://blog.csdn.net/ssdsafsdsd/article/details/8234736

?

在標準C和C++中，長度為0的數組是被禁止使用的。不過在GNU C中，存在一個非常奇怪的用法，那就是長度為0的數組，比如Array[0];很多人可能覺得不可思議，長度為0的數組是沒有什么意義的，不過在這兒，它表示的完全是另外的一層意思，這個特性是不可移植的，所以，如果你致力于編寫可移植，或者是稍稍需要跨平臺的代碼，這些Trick最好還是收起來的好。

???? 在GNU的指南中，它是如此寫道：

???? struct line

????? {

???????? int length;

???????? char contents[0];

????? };

????? //...ommit code here

???? {

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

??????? thisline->length = this_length;

???? }

?????? 這個用法主要用于變長Buffer，struct line的大小為4，結構體中的contents[0]不占用任何空間，甚至是一個指針的空間都不占，contents在這兒只是表示一個常量指針，這個特性是用編譯器來實現的，即在使用thisline->contents的時候，這個指針就是表示分配內存地址中的某塊buffer，比如 malloc (sizeof (struct line) + this_length)返回的是0x8f00a40,thisline->contents指向的位置就是(0x8f00a40 + sizeof(struct line)),而這兒sizeof(struct line)僅僅是一個int的四字節。

????? 對于這個用法，我們定義的結構體指針可以指向任意長度的內存buffer，這個技巧在變長buffer中使用起來相當方便。

????? 可能有朋友說，為什么不把最后的contents直接定義為一個指針呢？這兒的差別是這樣的，如果定義為一個指針，它需要占用4Bytes，并且在申請好內存后必須人為賦地址才可以。如果使用這個用法，這個常量指針不占用空間，并且無需賦值。

???? 但是，方便并不是絕對的，在釋放分配的內存的時候，由于函數free會認為*thisline 只是指向一個4字節的指針，即只會釋放length的空間，而對于后面占據大頭的buffer卻視而不見，這個就需要人為干預；而對于后面的聲明指針的方式，則可以直接用Free(thisline->contents)的方式釋放掉分配的內存。 ASSERT:除非必要，不要輕易使用這個功能，GNU C下可以編譯通過，所以你在使用vc++，那就不用嘗試了，編譯都無法通過。

總結：

用途?：長度為0的數組的主要用途是為了滿足需要變長度 的結構體。

用法?：在一個結構體的最后?，申明一個長度為0的數組，就可以使得這個結構體是可變長的。對于 編譯器來說，此時長度為0的數組并不占用空間，因為數組名本身不占空間，它只是一個偏移量，?數組名這個符號本身代 表了一個不可修改的地址常量?（注意：數組名永遠都不會是指針！?），但對于這個數組的大小，我們可以進行動態分配。例如：

typedef struct{
?????? int len;
?????? char data[0];
}test_t;

int my_length = 10;

test_t *p_test = (test_t *)malloc(sizeof(test_t) + my_length);
p_test->len = my_length;

......

free(p_test);????

之后對于結構體中的數組可以像一般的數組一樣進行訪問。

注意?：如果結構體是通過calloc、malloc或 者new等動態分配方式生成，在不需要時要釋放相應的空間。

優點?：比起在結構體中聲明一個指針變量、再進行動態分 配的辦法，這種方法效率要高。因為在訪問數組內容時，不需要間接訪問，避免了兩次訪存。

缺點?：在結構體中，數組為0的數組必須在最后聲明，使 用上有一定限制。

?

另一篇解釋：

?

在Linux系統里，/usr/include/linux/if_pppox.h里面有這樣一個結構：
struct pppoe_tag {
??? __u16 tag_type;
??? __u16 tag_len;
??? char tag_data[0];
} __attribute ((packed));
最 后一個成員為可變長的數組，對于TLV（Type-Length-Value）形式的結構，或者其他需要變長度的結構體，用這種方式定義最好。使用起來非 常方便，創建時，malloc一段結構體大小加上可變長數據長度的空間給它，可變長部分可按數組的方式訪問，釋放時，直接把整個結構體free掉就可以 了。例子如下：
struct pppoe_tag *sample_tag;
__u16 sample_tag_len = 10;
sample_tag = (struct pppoe_tag *)malloc(sizeof(struct pppoe_tag)+sizeof(char)*sample_tag_len);
sample_tag->tag_type = 0xffff;
sample_tag->tag_len = sample_tag_len;
sample_tag->tag_data[0]=....
...
釋放時，
free(sample_tag)

是否可以用 char *tag_data 代替呢？其實它和 char *tag_data 是有很大的區別，為了說明這個問題，我寫了以下的程序：
例1：test_size.c
10??struct tag1
20??{
30???? ?int a;
40???? ?int b;
50??}__attribute ((packed));
60?
70??struct tag2
80??{
90???? ?int a;
100???? ?int b;
110???? ??char *c;?
120??}__attribute ((packed));
130
140??struct tag3
150??{
160????? int a;
170????? int b;
180??????char c[0];
190??}__attribute ((packed));
200
210??struct tag4
220??{
230????? int a;
240????? int b;
250??????char c[1];
260??}__attribute ((packed));
270
280??int main()
290??{
300????? struct tag2 l_tag2;
310????? struct tag3 l_tag3;
320????? struct tag4 l_tag4;
330
340????? memset(&l_tag2,0,sizeof(struct tag2));
350????? memset(&l_tag3,0,sizeof(struct tag3));
360????? memset(&l_tag4,0,sizeof(struct tag4));
370
380????? printf("size of tag1 = %d\n",sizeof(struct tag1));
390????? printf("size of tag2 = %d\n",sizeof(struct tag2));
400????? printf("size of tag3 = %d\n",sizeof(struct tag3));
410
420????? printf("l_tag2 = %p,&l_tag2.c = %p,l_tag2.c = %p\n",&l_tag2,&l_tag2.c,l_tag2.c);
430????? printf("l_tag3 = %p,l_tag3.c = %p\n",&l_tag3,l_tag3.c);
440????? printf("l_tag4 = %p,l_tag4.c = %p\n",&l_tag4,l_tag4.c);
450????? exit(0);
460??}

__attribute ((packed)) 是為了強制不進行4字節對齊，這樣比較容易說明問題。
程序的運行結果如下：
size of tag1 = 8
size of tag2 = 12
size of tag3 = 8
size of tag4 = 9
l_tag2 = 0xbffffad0,&l_tag2.c = 0xbffffad8,l_tag2.c = (nil)
l_tag3 = 0xbffffac8,l_tag3.c = 0xbffffad0
l_tag4 = 0xbffffabc,l_tag4.c = 0xbffffac4

從上面程序和運行結果可以看出：tag1本身包括兩個32位整數，所以占了8個字節的空間。 tag2包括了兩個32位的整數，外加一個char *的指針，所以占了12個字節。tag3才是真正看出char c[0]和char *c的區別，char c[0]中的c并不是指針，是一個偏移量，這個偏移量指向的是a、b后面緊接著的空間，所以它其實并不占用任何空間。tag4更加補充說明了這一點。所 以，上面的struct pppoe_tag的最后一個成員如果?用char *tag_data定義，除了會占用多4個字節的指針變量外，用起來會比較不方便?：

方法一，創建時，可以首先為struct pppoe_tag分配一塊內存，再為tag_data分配內存，這樣在釋放時，要首先釋放tag_data占用的內存，再釋放pppoe_tag占用的內存；

方法二，創建時，直接為struct pppoe_tag分配一塊struct pppoe_tag大小加上tag_data的內存，從例一的420行可以看出，tag_data的內容要進行初始化，要讓tag_data指向strct pppoe_tag后面的內存。
struct pppoe_tag {
??? __u16 tag_type;
??? __u16 tag_len;
??? char *tag_data;
} __attribute ((packed));

struct pppoe_tag *sample_tag;
__u16 sample_tag_len = 10;
方法一：
sample_tag = (struct pppoe_tag *)malloc(sizeof(struct pppoe_tag));
sample_tag->tag_len = sample_tag_len;
sample_tag->tag_data = malloc(sizeof(char)*sample_tag_len);
sample_tag->tag_data[0]=...
釋放時：
free(sample_tag->tag_data);
free(sample_tag);

方法二：
sample_tag = (struct pppoe_tag *)malloc(sizeof(struct pppoe_tag)+sizeof(char)*sample_tag_len);
sample_tag->tag_len = sample_tag_len;
sample_tag->tag_data = ((char *)sample_tag)+sizeof(struct pppoe_tag);
sample_tag->tag_data[0]=...
釋放時：
free(sample_tag);
所以無論使用那種方法，都沒有char tag_data[0]這樣的定義來得方便。

講了這么多，其實本質上涉及到的是一個C語言里面的數組和指針的區別問題。char a[1]里面的a和char *b的b相同嗎？《?Programming Abstractions in C》（Roberts, E. S.，機械工業出版社，2004.6）82頁里面說：“arr is defined to be identical to &arr[0]”。也就是說，char a[1]里面的a實際是一個常量，等于&a[0]。而char *b是有一個實實在在的指針變量b存在。?所以，a=b是不允許的，而b=a是允許的。?兩種變量都支持下標式的訪問，那么對于a[0]和b[0]本質上是否有區別？我們可以通過一個例子來說明。

例二：
10??#include <stdio.h>
20??#include <stdlib.h>
30
40??int main()
50??{
60????? char a[10];
70????? char *b;
80
90????? a[2]=0xfe;
100????? b[2]=0xfe;
110????? exit(0);
120??}

編譯后，用objdump可以看到它的匯編：
080483f0 <main>:
?80483f0:?????? 55????????????????????? push?? %ebp
?80483f1:?????? 89 e5?????????????????? mov??? %esp,%ebp
?80483f3:?????? 83 ec 18??????????????? sub??? $0x18,%esp
?80483f6:?????? c6 45 f6 fe???????????? movb?? $0xfe,0xfffffff6(%ebp)
?80483fa:?????? 8b 45 f0??????????????? mov??? 0xfffffff0(%ebp),%eax
?80483fd:?????? 83 c0 02????????????????add??? $0x2,%eax
?8048400:?????? c6 00 fe??????????????? movb?? $0xfe,(%eax)
?8048403:?????? 83 c4 f4??????????????? add??? $0xfffffff4,%esp
?8048406:?????? 6a 00?????????????????? push?? $0x0
?8048408:?????? e8 f3 fe ff ff????????? call?? 8048300 <_init+0x68>
?804840d:?????? 83 c4 10??????????????? add??? $0x10,%esp
?8048410:?????? c9????????????????????? leave
?8048411:?????? c3????????????????????? ret
?8048412:?????? 8d b4 26 00 00 00 00??? lea??? 0x0(%esi,1),%esi
?8048419:?????? 8d bc 27 00 00 00 00??? lea??? 0x0(%edi,1),%edi

可以看出，a[2]＝0xfe是直接尋址，直接將0xfe寫入&a[0]+2的地址，而b[2]=0xfe是間接尋址，先將b的內容（地址）拿出來，加2，再0xfe寫入計算出來的地址。所以a[0]和b[0]本質上是不同的。

但當數組作為參數時，和指針就沒有區別了。
int do1(char a[],int len);
int do2(char *a,int len);
這兩個函數中的a并無任何區別。都是實實在在存在的指針變量。

順便再說一下，對于struct pppoe_tag的最后一個成員的定義是char tag_data[0]，某些編譯器不支持長度為0的數組的定義，在這種情況下，只能將它定義成char tag_data[1]，使用方法相同。

?

總結：通過上面的轉載的文章，可以清晰的發現，這種方法的優勢其實就是為了簡化內存的管理， 我們假設在理想的內存狀態下，那么分配的內存空間，可以是按序下來的（當然，實際因為內存碎片等的原因會不同的）我們可以利用最后一個數組的指針直接無間 隔的跳到分配的數組緩沖區，這在LINUX下非常常見，在WINDOWS下的我只是在MFC里見過類似的，別的情況下記不清楚了，只記得MFC里的是這么 講的，可以用分配的結構體的指針直接+1.

總結

以上是生活随笔為你收集整理的GNU C中的零长度数组的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。