C语言中变长数组的使用方法

先说说我的理解：

struct example{

__u16 tag_type;

__u16 tag_len;

char tag_data[0];

} __attribute ((packed));

1. 存在的意义：当结构体的长度变长时，例如里面有一个字符串时，为了方便管理内存。

这个结构体不要用struct example a的方式定义， 而应用struct example *a; a = (struct example *)malloc(sizeof(struct example) + extrasize);的形式。extrasize是想额外申请的空间，就是字符串的长度。

2. 如何使用里面的数据？

前面的数据项不用说了，后面的tag_data直接就是我们申请的额外的地址的开始地址。所以，很好用

3. 如何释放申请的地址空间？

直接free(a)就好。有些人可能认为后面的空间没有释放，其实不然。因为malloc申请的空间系统是需要进行管理的，你申请了多少，当你释放的时候，就释放多少。并不是根据你的数据类型来的，否则你说 char *p; p  = malloc(20); 然后free(p);系统该释放多少空间呢。 至于系统如何管理的，貌似是通过一个链表进行的，记不清了。

4. 附1

为了解决这个疑惑，后来看了几篇文章，感谢他们。

后来就是人提到过有些编译器不支持0长数组，那怎么办呢?很简单，将数组长度定为1即可，这样仅仅浪费一个字节的空间（字节对齐的话另当别论）。这样做还有另外一个好处就是不用记录这个字符串的长度， 因为本来就存了一个字节的空间，可用这一个字节的空间来标识这个字符串是否为空。

5.附2

有人可能会问，为什么最后一个数据项不设置成一个指针呢？char tag_data[0]; 和char *tag_data;有什么区别呢？

第一个问题：最好不要设置成指针，因为这样的话，你得为tag_data指针重新申请空间，申请的空间还不连续；其次，释放的时候很麻烦，必须先释放内部的指针，但是这个往往是人最容易忽略而造成内存呢泄露的原因。

第二个问题：这个问题貌似问的很傻，因为这是两种不同类型的数据，占据的地址大小都不同。其实不然，这个问题设计到指针和数组的区别问题。

指针和数组很多人都把他们之间画成等号了，这是个错误，希望各位不要犯。他们俩只有在作为函数参数的时候才是真正的一摸一样，都是指针变量，其他情况都不一样。最大的区别：数组是直接寻址的，指针是间接寻址的。array[0]中， array 是一个常量，等于&(a[0]); 而指针变量是一个变量。像array = a就不允许赋值（常量怎么可能作为赋值运算符的左操作数呢？），a = array就是允许的。

6.最后

这个东西用在内存池的管理中用得很多。内存池，这个东西，说起来很吓唬人，其实就是那么回事。一个程序或者动态库维护的一个全局的数组而已，无它。比如说一个c/s架构的服务器，客户端调用一个预先编好的动态库中的函数，一般来说不会没发一个请求网络就帮你投递过去，那样数据太小了。一般都是在动态库中维护一个数组，把请求往里面填，填到满的时候发送出去；或者用户强行要求发送出去。

这个就跟标准i/o库很像了，其实里面也是一段缓存，通过这个缓存使得内存和外存的数据交换不是那么频繁，提高了效率。用户也可以使用fflush()函数强行写到外存。原理都是类似的。

经常遇到的结构形状如下：

struct buffer
{
    int data_len;   //长度
    char data[0];  //起始地址
};

在这个结构中，data是一个数组名；但该数组没有元素；该数组的真实地址紧随结构体buffer之后，而这个地址就是结构体后面数据的地址（如果给这个结构体分配的内容大于这个结构体实际大小，后面多余的部分就是这个data的内容）；这种声明方法可以巧妙的实现C语言里的数组扩展。

　　写个程序对比char data[0]，char *data, char data[]，如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

typedef struct
{
    int data_len;
    char data[0];
}buff_st_1;

typedef struct
{
    int data_len;
    char *data;
}buff_st_2;

typedef struct
{
    int data_len;
    char data[];
}buff_st_3;

int main()
{
    printf("sizeof(buff_st_1)=%u\n", sizeof(buff_st_1));
    printf("sizeof(buff_st_2)=%u\n", sizeof(buff_st_2));
    printf("sizeof(buff_st_3)=%u\n", sizeof(buff_st_3));

    buff_st_1 buff1;
    buff_st_2 buff2;
    buff_st_3 buff3;

    printf("buff1 address:%p,buff1.data_len address:%p,buff1.data address:%p\n",
        &buff1, &(buff1.data_len), buff1.data);

    printf("buff2 address:%p,buff2.data_len address:%p,buff2.data address:%p\n",
        &buff2, &(buff2.data_len), buff2.data);

    printf("buff3 address:%p,buff3.data_len address:%p,buff3.data address:%p\n",
        &buff3, &(buff3.data_len), buff3.data);

    return 0;
}

从结果可以看出data[0]和data[]不占用空间，且地址紧跟在结构后面，而char *data作为指针，占用4个字节，地址不在结构之后。

3、实际当中的用法

在实际程序中，数据的长度很多是未知的，这样通过变长的数组可以方便的节省空间。对指针操作，方便数据类型的转换。测试程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

typedef struct
{
    int data_len;
    char data[0];
}buff_st_1;

typedef struct
{
    int data_len;
    char *data;
}buff_st_2;

typedef struct
{
    int data_len;
    char data[];
}buff_st_3;

typedef struct
{
    uint32_t id;
    uint32_t age;
}student_st;

void print_stu(const student_st *stu)
{
    printf("id:%u,age:%u\n", stu->id, stu->age);
}

int main()
{
    student_st *stu = (student_st *)malloc(sizeof(student_st));
    stu->id = 100;
    stu->age = 23;

    student_st *tmp = NULL;

    buff_st_1 *buff1 = (buff_st_1 *)malloc(sizeof(buff_st_1) + sizeof(student_st));
    buff1->data_len = sizeof(student_st);
    memcpy(buff1->data, stu, buff1->data_len);
    printf("buff1 address:%p,buff1->data_len address:%p,buff1->data address:%p\n",
        buff1, &(buff1->data_len), buff1->data);

    tmp = (student_st*)buff1->data;
    print_stu(tmp);

    buff_st_2 *buff2 = (buff_st_2 *)malloc(sizeof(buff_st_2));
    buff2->data_len = sizeof(student_st);
    buff2->data = (char *)malloc(buff2->data_len);
    memcpy(buff2->data, stu, buff2->data_len);
    printf("buff2 address:%p,buff2->data_len address:%p,buff2->data address:%p\n",
        buff2, &(buff2->data_len), buff2->data);

    tmp = (student_st *)buff2->data;
    print_stu(tmp);

    buff_st_3 *buff3 = (buff_st_3 *)malloc(sizeof(buff_st_3) + sizeof(student_st));
    buff3->data_len = sizeof(student_st);
    memcpy(buff3->data, stu, buff3->data_len);
    printf("buff3 address:%p,buff3->data_len address:%p,buff3->data address:%p\n",
        buff3, &(buff3->data_len), buff3->data);

    tmp = (student_st*)buff1->data;
    print_stu(tmp);

    free(buff1);

    free(buff2->data);
    free(buff2);

    free(buff3);
    free(stu);
    return 0;
}

程序执行结果如下：

采用char *data，需要进行二次分配，操作比较麻烦，很容易造成内存泄漏。而直接采用变长的数组，只需要分配一次，然后进行取值即可以。