變長結構體

結構體中最後一字段爲長度爲0的字符數組

struct mystruct{

int type;

int len;

char str[0];//目的就是爲了獲得變長數組

};

len = 2;

struct mystruct *my = (struct mystruct *)malloc(sizeof(struct mystruct)+sizeof(int)*len);

my->len = len;

my->type = 1;

my->str[0] = 10;

my->str[1] = 12;

free(my);

優點有：

1.結構體無需分配新的存儲變長數組的空間；

2.釋放比較方便；

(轉載)結構體最後的長度爲0或1數組的作用

LINUX編程 2010-06-11 10:27:17 閱讀77 評論1   字號：大中小 訂閱

其實很早在看LINUX下就看到這個東西，後來在MFC內存池裏同樣也看到了類似的東西，還依照MFC寫過一個類似的小內存池，（MFC用的是return this + 1）後來在李先靜的《系統程序員成長計劃》裏看到了類似的定義，於是心裏想着總結一下，結果發現網上已經有牛人總結的很好了，於是乎就轉了過來，謝謝你們的分享，這是我前進的動力！ 同時，需要引起注意的：ISO/IEC 9899-1999裏面，這麼寫是非法的，這個僅僅是GNU C的擴展，gcc可以允許這一語法現象的存在。但最新的C/C++不知道是否可以，我沒有測試過。C99允許。 結構體最後使用0或1的長度數組的原因，主要是爲了方便的管理內存緩衝區，如果你直接使用指針而不使用數組，那麼，你在分配內存緩衝區時，就必須分配結構體一次，然後再分配結構體內的指針一次，（而此時分配的內存已經與結構體的內存不連續了，所以要分別管理即申請和釋放）而如果使用數組，那麼只需要一次就可以全部分配出來，（見下面的例子），反過來，釋放時也是一樣，使用數組，一次釋放，使用指針，得先釋放結構體內的指針，再釋放結構體。還不能顛倒次序。 其實就是分配一段連續的的內存，減少內存的碎片化。

標題	結構體最後的長度爲0或者1的數組     選擇自 googol4u 的 Blog
關鍵字	結構體最後的長度爲0或者1的數組
出處

在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   �p
 80483f1:       89 e5                   mov    %esp,�p
 80483f3:       83 ec 18                sub    $0x18,%esp
 80483f6:       c6 45 f6 fe             movb   $0xfe,0xfffffff6(�p)
 80483fa:       8b 45 f0                mov    0xfffffff0(�p),�x
 80483fd:       83 c0 02                add    $0x2,�x
 8048400:       c6 00 fe                movb   $0xfe,(�x)
 8048403:       83 c4 f4                add    $0xfffffff4,%esp
 8048406:       6a 00                   push   $0x0
 8048408:       e8 f3 fe ff ff          call   8048300 <_init+0x68>
 804840d: