GNU C的定義長度為0的數組


原文地址: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,0x18,0xfe,0xfffffff6(%ebp)
80483fa:       8b 45 f0                mov    0xfffffff0(%ebp),%eax
80483fd:       83 c0 02                add    $0x2,%eax
8048400:       c6 00 fe                movb   0xfe,(0xfe,(0xfffffff4,%esp
8048406:       6a 00                   push  0x08048408:e8f3feffffcall8048300<init+0x68>804840d:83c410add0x08048408:e8f3feffffcall8048300<init+0x68>804840d:83c410add0x10,%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.


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM