linux 内核中变长数组

最新推荐文章于 2025-06-23 20:27:58 发布

转载最新推荐文章于 2025-06-23 20:27:58 发布 · 3.1k 阅读

linux驱动专栏收录该内容

38 篇文章

订阅专栏

本文深入探讨了C语言中变长数组的使用方式、内存分配与释放，以及其在内存池管理中的应用。通过具体示例展示了如何在结构体中灵活运用变长数组来节省内存资源，方便数据类型转换，并提供了内存池管理的基本概念及其实现方式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

先说说我的理解：

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[]，如下所示：

[cpp] view plain copy

#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、实际当中的用法

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

 
  
   
    
     [cpp] 
     view plain
     copy
     
     
    
   
   #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，需要进行二次分配，操作比较麻烦，很容易造成内存泄漏。而直接采用变长的数组，只需要分配一次，然后进行取值即可以。

内核中的实例:

struct at76_command *cmd_buf = kmalloc(sizeof(struct at76_command) +
					       buf_size, GFP_KERNEL);

	if (!cmd_buf)
		return -ENOMEM;

	cmd_buf->cmd = cmd;
	cmd_buf->reserved = 0;
	cmd_buf->size = cpu_to_le16(buf_size);
	memcpy(cmd_buf->data, buf, buf_size);

	at76_dbg_dump(DBG_CMD, cmd_buf, sizeof(struct at76_command) + buf_size,
		      "issuing command %s (0x%02x)",
		      at76_get_cmd_string(cmd), cmd);

	ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x0e,
			      USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
			      0, 0, cmd_buf,
			      sizeof(struct at76_command) + buf_size,
			      USB_CTRL_GET_TIMEOUT);
	kfree(cmd_buf);