嵌入式c语言自我修养 05：零长度数组-凯发app官方网站

凯发app官方网站-凯发k8官网下载客户端中心 | | 凯发app官方网站-凯发k8官网下载客户端中心

宅学部落

凯发app官方网站首页　| 　　| 　

令狐大侠

  • 博客访问： 822018
  • 博文数量： 15
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 175
  • 用 户 组： 普通用户
  • 注册时间： 2019-02-01 13:13
个人简介

专注嵌入式、linux精品教程。 微信公众号：宅学部落 嵌入式视频淘宝店：https://wanglitao.taobao.com

文章分类

（15）

  • （1）
  • （14）
  • （0）
文章存档

（1）

（1）

（13）

我的朋友
最近访客
推荐博文
相关博文
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
嵌入式c语言自我修养 05：零长度数组

分类： 嵌入式

2019-03-22 08:02:04

5.1 什么是零长度数组

顾名思义，零长度数组就是长度为0的数组。

ansi c 标准规定：定义一个数组时，数组的长度必须是一个常数，即数组的长度在编译的时候是确定的。在ansi c 中定义一个数组的方法如下： 

int a[10];

c99 新标准规定：可以定义一个变长数组。 

int len; int a[len];

也就是说，数组的长度在编译时是未确定的，在程序运行的时候才确定，甚至可以由用户指定大小。比如，我们可以定义一个数组，然后在程序运行时才指定这个数组的大小，还可以通过输入数据来初始化数组，示例代码如下。

  1. int main(void)
  2. {
  3.     int len;

  5.     printf("input array len:");
  6.     scanf("%d",&len);
  7.     int a[len];

  9.     for(int i=0;i<len;i)
  10.     {
  11.         printf("a[%d]= ",i);
  12.         scanf("%d",&a[i]);
  13.     }

  15.       printf("a array print:\n");
  16.     for(int i=0;i<len;i)
  17.         printf("a[%d] = %d\n",i,a[i]);

  19.     return 0;
  20. }


在这个程序中，我们定义一个变量 len，作为数组的长度。程序运行后，我们可以通过输入指定数组的长度并初始化，最后再将数组的元素打印出来。程序的运行结果如下：

  1. input array len:3
  2. a[0]= 6
  3. a[1]= 7
  4. a[2]= 8
  5. a array print:
  6. a[0] = 6
  7. a[1] = 7
  8. a[2] = 8


gnu c 可能觉得变长数组还不过瘾，再来一个实锤：支持零长度数组。这下没有其它编译器比我狠吧！是的，如果我们在程序中定义一个零长度数组，你会发现除了 gcc 编译器，在其它编译环境下可能就编译通不过或者有警告信息。零长度数组的定义如下： 

int a[0];

零长度数组有一个奇特的地方，就是它不占用内存存储空间。我们使用 sizeof 关键字来查看一下零长度数组在内存中所占存储空间的大小，代码如下。

  1. int buffer[0];
  2. int main(void)
  3. {
  4.     printf("%d\n", sizeof(buffer));
  5.     return 0;
  6. }


在这个程序中，我们定义一个零长度数组，使用 sizeof 查看其大小可以看到：零长度数组在内存中不占用空间，大小为0。

零长度数组一般单独使用的机会很少，它常常作为结构体的一个成员，构成一个变长结构体。

  1. struct buffer{
  2.     int len;
  3.     int a[0];
  4. };
  5. int main(void)
  6. {
  7.       printf("%d\n",sizeof(struct buffer));
  8.       return 0;
  9. }


零长度数组在结构体中同样不占用存储空间，所以 buffer 结构体的大小为4。


5.2 零长度数组使用示例

零长度数组经常以变长结构体的形式，在某些特殊的应用场合，被程序员使用。在一个变长结构体中，零长度数组不占用结构体的存储空间，但是我们可以通过使用结构体的成员 a 去访问内存，非常方便。变长结构体的使用示例如下。

  1. struct buffer{
  2.     int len;
  3.     int a[0];
  4. };
  5. int main(void)
  6. {
  7.     struct buffer *buf;
  8.     buf = (struct buffer *)malloc \
  9.         (sizeof(struct buffer) 20);

  11.     buf->len = 20;
  12.     strcpy(buf->a, "hello wanglitao!\n");
  13.     puts(buf->a);

  15.     free(buf);
  16.     return 0;
  17. }


在这个程序中，我们使用 malloc 申请一片内存，大小为 sizeof(buffer) 20，即24个字节大小。其中4个字节用来存储结构体指针 buf 指向的结构体类型变量，另外20个字节空间，才是我们真正使用的内存空间。我们可以通过结构体成员 a，直接访问这片内存。

通过这种灵活的动态内存申请方式，这个 buffer 结构体表示的一片内存缓冲区，就可以随时调整，可大可小。这个特性，在一些场合非常有用。比如，现在很多在线视频网站，都支持多种格式的视频播放：普清、高清、超清、1080p、蓝光甚至4k。如果我们本地程序需要在内存中申请一个 buffer 用来缓存解码后的视频数据，那么，不同的播放格式，需要的 buffer 大小是不一样的。如果我们按照 4k 的标准去申请内存，那么当播放普清视频时，就用不了这么大的缓冲区，白白浪费内存。而使用变长结构体，我们就可以根据用户的播放格式设置，灵活地申请不同大小的 buffer，大大节省了内存空间。


5.3 零长度数组在内核中的使用

零长度数组在内核中，一般以变长结构体的形式使用。今天我们就分析一下 linux 内核中的 usb 驱动。在网卡驱动中，大家可能都比较熟悉一个名字：套接字缓冲区，即 socket buffer，用来传输网络数据包。同样，在 usb 驱动中，也有一个类似的东西，叫 urb，其全名为 usb request block，即 usb 请求块，用来传输 usb 数据包。

  1. struct urb {
  2.     struct kref kref;
  3.     void *hcpriv;
  4.     atomic_t use_count;
  5.     atomic_t reject;
  6.     int unlinked;

  8.     struct list_head urb_list;
  9.     struct list_head anchor_list;
  10.     struct usb_anchor *anchor;
  11.     struct usb_device *dev;
  12.     struct usb_host_endpoint *ep;
  13.     unsigned int pipe;
  14.     unsigned int stream_id;
  15.     int status;
  16.     unsigned int transfer_flags;
  17.     void *transfer_buffer;
  18.     dma_addr_t transfer_dma;
  19.     struct scatterlist *sg;
  20.     int num_mapped_sgs;
  21.     int num_sgs;
  22.     u32 transfer_buffer_length;
  23.     u32 actual_length;
  24.     unsigned char *setup_packet;
  25.     dma_addr_t setup_dma;
  26.     int start_frame;
  27.     int number_of_packets;
  28.     int interval;

  30.     int error_count;
  31.     void *con代写论文、pos;
  32.     usb_complete_t complete;
  33.     struct usb_iso_packet_descriptor iso_frame_desc[0];
  34. };


在这个结构体内定义了 usb 数据包的传输方向、传输地址、传输大小、传输模式等。这些细节我们不深究，我们只看最后一个成员： 

struct usb_iso_packet_descriptor iso_frame_desc[0];

在 urb 结构体的最后，定义一个零长度数组，主要用于 usb 的同步传输。usb 有4种传输模式：中断传输、控制传输、批量传输和同步传输。不同的 usb 设备对传输速度、传输数据安全性的要求不同，所采用的传输模式是不同的。usb 摄像头对视频或图像的传输实时性要求较高，对数据的丢帧不是很在意，丢一帧无所谓 ，接着往下传。所以 usb 摄像头采用的是 usb 同步传输模式。

现在淘宝上的 usb 摄像头，打开它的说明书，一般会支持多种分辨率：从16*16到高清720p多种格式。不同分辨率的视频传输，对于一帧图像数据，对 usb 的传输数据包的大小和个数需求是不一样的。那usb到底该如何设计，去适配这种不同大小的数据传输要求，但又不影响 usb 的其它传输模式呢？答案就在结构体内的这个零长度数组上。

当用户设置不同的分辨率传输视频，usb 就需要使用不同大小和个数的数据包来传输一帧视频数据。通过零长度数组构成的这个变长结构体就可以满足这个要求。可以根据一帧图像数据的大小，灵活地去申请内存空间，满足不同大小的数据传输。但这个零长度数组又不占用结构体的存储空间，当 usb 使用其它模式传输时，不受任何影响，完全可以当这个零长度数组不存在。所以，不得不说，这样的设计真是妙！


5.3 思考：为什么不使用指针来代替零长度数组?

大家在各种场合，可能常常会看到这样的字眼：数组名在作为函数参数进行参数传递时，就相当于是一个指针。在这里，我们千万别被这句话迷惑了：数组名在作为函数参数传递时，确实传递的是一个地址，但数组名绝不是指针，两者不是同一个东西。数组名用来表征一块连续内存存储空间的地址，而指针是一个变量，编译器要给它单独再分配一个内存空间，用来存放它指向的变量的地址。我们看下面这个程序。

  1. struct buffer1{
  2.     int len;
  3.     int a[0];
  4. };
  5. struct buffer2{
  6.     int len;
  7.     int *a;
  8. };
  9. int main(void)
  10. {
  11.     printf("buffer1: %d\n", sizeof(struct buffer1));
  12.     printf("buffer2: %d\n", sizeof(struct buffer2));
  13.     return 0;
  14. }


运行结果分别为： 

buffer1：4 buffer2：8

对于一个指针变量，编译器要为这个指针变量单独分配一个存储空间，然后在这个存储空间上存放另一个变量的地址，我们就说这个指针指向这个变量。而数组名，编译器不会再给其分配一个存储空间的，它仅仅是一个符号，跟函数名一样，用来表示一个地址。我们接下来看另一个程序。

  1. //hello.c
  2. int array1[10] ={1,2,3,4,5,6,7,8,9};
  3. int array2[0];
  4. int *p = &array1[5];
  5. int main(void)
  6. {
  7.     return 0;
  8. }


在这个程序中，我们分别定义一个普通数组、一个零长度数组和一个指针变量。其中这个指针变量 p 的值为 array1[5] 这个数组元素的地址，也就是说指针 p 指向 arraay1[5]。我们接着对这个程序使用 arm 交叉编译器进行编译，并进行反汇编。 

$ arm-linux-gnueabi-gcc hello.c -o a.out $ arm-linux-gnueabi-objdump -d a.out

从反汇编生成的汇编代码中，我们找到 array1 和指针变量 p 的汇编代码。

  1. 00021024 <array1>:
  2.    21024: 00000001 andeq r0, r0, r1
  3.    21028: 00000002 andeq r0, r0, r2
  4.    2102c: 00000003 andeq r0, r0, r3
  5.    21030: 00000004 andeq r0, r0, r4
  6.    21034: 00000005 andeq r0, r0, r5
  7.    21038: 00000006 andeq r0, r0, r6
  8.    2103c: 00000007 andeq r0, r0, r7
  9.    21040: 00000008 andeq r0, r0, r8
  10.    21044: 00000009 andeq r0, r0, r9
  11.    21048: 00000000 andeq r0, r0, r0
  12. 0002104c <p>:
  13.    2104c: 00021038 andeq r1, r2, r8, lsr r0
  14. disassembly of section .bss:

  16. 00021050 <__bss_start>:
  17.    21050: 00000000 andeq r0, r0, r0


从汇编代码中，可以看到，对于长度为10的数组 array1[10]，编译器给它分配了从 0x21024--0x21048 一共40个字节的存储空间，但并没有给数组名 array1 单独分配存储空间，数组名 array1 仅仅表示这40个连续存储空间的首地址，即数组元素 array1[0] 的地址。而对于 array2[0] 这个零长度数组，编译器并没有给它分配存储空间，此时的 array2 仅仅是一个符号，用来表示内存中的某个地址，我们可以通过查看可执行文件 a.out 的符号表来找到这个地址值。

  1. $ readelf -s a.out
  2.     88: 00021024 40 object global default 23 array1
  3.     89: 00021054 0 notype global default 24 _bss_end__
  4.     90: 00021050 0 notype global default 23 _edata
  5.     91: 0002104c 4 object global default 23 p
  6.     92: 00010480 0 func global default 14 _fini
  7.     93: 00021054 0 notype global default 24 __bss_end__
  8.     94: 0002101c 0 notype global default 23 __data_start_
  9.     96: 00000000 0 notype weak default und __gmon_start__
  10.     97: 00021020 0 object global hidden 23 __dso_handle
  11.     98: 00010488 4 object global default 15 _io_stdin_used
  12.     99: 0001041c 96 func global default 13 __libc_csu_init
  13.     100: 00021054 0 object global default 24 array2
  14.     101: 00021054 0 notype global default 24 _end
  15.     102: 000102d8 0 func global default 13 _start
  16.     103: 00021054 0 notype global default 24 __end__
  17.     104: 00021050 0 notype global default 24 __bss_start
  18.     105: 00010400 28 func global default 13 main
  19.     107: 00021050 0 object global hidden 23 __tmc_end__
  20.     110: 00010294 0 func global default 11 _init


从符号表里可以看到，array2 的地址为 0x21054，在程序 bss 段的后面。array2 符号表示的默认地址是一片未使用的内存空间，仅此而已，编译器绝不会单独再给其分配一个内存空间来存储数组名。看到这里，也许你就明白了：数组名和指针并不是一回事，数组名虽然在作为函数参数时，可以当一个地址使用，但是两者不能划等号。菜刀有时候可以当武器用，但是你不能说菜刀就是武器。

至于为什么不用指针，很简单。使用指针的话，指针本身也会占用存储空间不说，根据上面的 usb 驱动的案例分析，你会发现，它远远没有零长度数组用得巧妙——不会对结构体定义造成冗余，而且使用起来也很方便。

阅读(109459) | 评论(0) | 转发(1) |
0

上一篇：

下一篇：嵌入式c语言自我修养 06：u-boot镜像自拷贝分析：section属性

给主人留下些什么吧！~~
| | | | |

凯发app官方网站 copyright 2001-2010 chinaunix.net all rights reserved 北京皓辰网域网络信息技术有限公司. 凯发k8官网下载客户端中心的版权所有

感谢所有关心和支持过chinaunix的朋友们
")); function link(t){ var href= $(t).attr('href'); href ="?url=" encodeuricomponent(location.href); $(t).attr('href',href); //setcookie("returnouturl", location.href, 60, "/"); }
网站地图