结构体最后的长度为0或者1的数组

 在Linux系统里，/usr/include/linux/if_pppox.h里面有这样一个结构：

1 struct  pppoe_tag  {
2    __u16 tag_type;
3    __u16 tag_len;
4    char tag_data[0];
5}  __attribute ((packed));

最后一个成员为可变长的数组，对于TLV（Type-Length-Value）形式的结构，或者其他需要变长度的结构体，用这种方式定义最好。使用起来非常方便，创建时，malloc一段结构体大小加上可变长数据长度的空间给它，可变长部分可按数组的方式访问，释放时，直接把整个结构体free掉就可以了。例子如下：

1 struct  pppoe_tag  * sample_tag;
2 __u16 sample_tag_len  =   10 ;
3 sample_tag  =  ( struct  pppoe_tag  * )malloc( sizeof ( struct  pppoe_tag) + sizeof ( char ) * sample_tag_len);
4 sample_tag -> tag_type  =   0xffff ;
5 sample_tag -> tag_len  =  sample_tag_len;
6 sample_tag -> tag_data[ 0 ] = .
7

释放时，

1 free(sample_tag)

是否可以用 char *tag_data 代替呢？其实它和 char *tag_data 是有很大的区别，为了说明这个问题，我写了以下的程序：
例1：test_size.c

 1 struct  tag1
 2 {
 3    int a;
 4    int b;
 5} __attribute ((packed));
 6
 7 struct  tag2
 8 {
 9   int a;
10   int b;
11   char *c;
12} __attribute ((packed));
13
14 struct  tag3
15 {
16   int a;
17   int b;
18   char c[0];
19} __attribute ((packed));
20
21 struct  tag4
22 {
23    int a;
24    int b;
25    char c[1];
26} __attribute ((packed));
27
28 int  main()
29 {
30    struct tag2 l_tag2;
31    struct tag3 l_tag3;
32    struct tag4 l_tag4;
33    
34    memset(&l_tag2,0,sizeof(struct tag2));
35    memset(&l_tag3,0,sizeof(struct tag3));
36    memset(&l_tag4,0,sizeof(struct tag4));
37
38    printf("size of tag1 = %d\n",sizeof(struct tag1));
39    printf("size of tag2 = %d\n",sizeof(struct tag2));
40    printf("size of tag3 = %d\n",sizeof(struct tag3));
41    
42    printf("l_tag2 = %p,&l_tag2.c = %p,l_tag2.c = %p\n",&l_tag2,&l_tag2.c,l_tag2.c);
43    printf("l_tag3 = %p,l_tag3.c = %p\n",&l_tag3,l_tag3.c);
44    printf("l_tag4 = %p,l_tag4.c = %p\n",&l_tag4,l_tag4.c);
45    exit(0);
46}

__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后面的内存。

1 struct  pppoe_tag  {
2    __u16 tag_type;
3    __u16 tag_len;
4    char *tag_data;
5}  __attribute ((packed));
6
7 struct  pppoe_tag  * sample_tag;
8 __u16 sample_tag_len  =   10 ;

方法一：

1 sample_tag  =  ( struct  pppoe_tag  * )malloc( sizeof ( struct  pppoe_tag));
2 sample_tag -> tag_len  =  sample_tag_len;
3 sample_tag -> tag_data  =  malloc( sizeof ( char ) * sample_tag_len);
4 sample_tag -> tag_data[ 0 ] =

释放时：

1 free(sample_tag -> tag_data);
2 free(sample_tag);

方法二：

1 sample_tag  =  ( struct  pppoe_tag  * )malloc( sizeof ( struct  pppoe_tag) + sizeof ( char ) * sample_tag_len);
2 sample_tag -> tag_len  =  sample_tag_len;
3 sample_tag -> tag_data  =  (( char   * )sample_tag) + sizeof ( struct  pppoe_tag);
4 sample_tag -> tag_data[ 0 ] =

释放时：

1 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]，使用方法相同