一万字详解C语言中长度为零的数组

最新推荐文章于 2024-06-05 22:11:04 发布
最新推荐文章于 2024-06-05 22:11:04 发布
阅读量498 收藏 3
点赞数
文章标签： C语言 零长度数组 变长结构体 内存管理 GCC扩展
原文链接：https://mp.weixin.qq.com/s?__biz=Mzg2ODUxNzQxMw==&mid=2247488911&idx=1&sn=d7534c2e1841326696f2c3d898f399ea&chksm=ceaa46c5f9ddcfd3d50782786f1882156e9dabfb38acb1682c3a8cab2c1a51776009ec22cbaa&scene=126&&sessionid=0
版权

点击蓝字

d97c20799e56a203640f549412a94998.png

关注我们

零长度数组概念：

众所周知, GNU/GCC 在标准的 C/C++ 基础上做了有实用性的扩展, 零长度数组（Arrays of Length Zero） 就是其中一个知名的扩展.

多数情况下, 其应用在变长数组中, 其定义如下：

struct Packet
{
    int state;
  int len;
  char cData[0]; //这里的0长结构体就为变长结构体提供了非常好的支持
};

首先对 0 长度数组, 也叫柔性数组，做一个解释 ：

  • 用途 : 长度为0的数组的主要用途是为了满足需要变长度的结构体；

  • 用法 : 在一个结构体的最后,声明一个长度为 0 的数组, 就可以使得这个结构体是可变长的. 对于编译器来说, 此时长度为 0 的数组并不占用空间, 因为数组名本身不占空间, 它只是一个偏移量, 数组名这个符号本身代表了一个不可修改的地址常量

（注意 : 数组名永远都不会是指针!）, 但对于这个数组的大小, 我们可以进行动态分配。

注意 ：如果结构体是通过 calloc、malloc 或 者 new 等动态分配方式生成，在不需要时要释放相应的空间。

优点 ：比起在结构体中声明一个指针变量、再进行动态分 配的办法，这种方法效率要高。因为在访问数组内容时，不需要间接访问，避免了两次访存。

缺点 ：在结构体中，数组为 0 的数组必须在最后声明，使用上有一定限制。

对于编译器而言, 数组名仅仅是一个符号, 它不会占用任何空间, 它在结构体中, 只是代表了一个偏移量, 代表一个不可修改的地址常量！

0 长度数组的用途：

我们设想这样一个场景, 我们在网络通信过程中使用的数据缓冲区, 缓冲区包括一个 len 字段和 data 字段, 分别标识数据的长度和传输的数据, 我们常见的有几种设计思路：

  • 定长数据缓冲区, 设置一个足够大小 MAX_LENGTH 的数据缓冲区

  • 设置一个指向实际数据的指针, 每次使用时, 按照数据的长度动态的开辟数据缓冲区的空间

我们从实际场景中应用的设计来考虑他们的优劣. 主要考虑的有, 缓冲区空间的开辟、释放和访问。

1、定长包(开辟空间, 释放, 访问)：

比如我要发送 1024 字节的数据, 如果用定长包, 假设定长包的长度 MAX_LENGTH 为 2048, 就会浪费 1024 个字节的空间, 也会造成不必要的流量浪费：

  • 数据结构定义：

//  定长缓冲区
struct max_buffer
{
    int     len;    
    char    data[MAX_LENGTH];
};

  • 数据结构大小：考虑对齐, 那么数据结构的大小 >= sizeof(int) + sizeof(char) * MAX_LENGTH

由于考虑到数据的溢出, 变长数据包中的 data 数组长度一般会设置得足够长足以容纳最大的数据, 因此 max_buffer 中的 data 数组很多情况下都没有填满数据, 因此造成了浪费。

  • 数据包的构造：假如我们要发送 CURR_LENGTH = 1024 个字节, 我们如何构造这个数据包呢；一般来说, 我们会返回一个指向缓冲区数据结构 max_buffer 的指针：

//  开辟
if ((mbuffer = (struct max_buffer *)malloc(sizeof(struct max_buffer))) != NULL)    
{
  mbuffer->len = CURR_LENGTH;
  memcpy(mbuffer->data, "Hello World", CURR_LENGTH);
  printf("%d, %s\n", mbuffer->len, mbuffer->data);
}

  • 访问：这段内存要分两部分使用；前部分 4 个字节 p->len, 作为包头(就是多出来的那部分)，这个包头是用来描述紧接着包头后面的数据部分的长度，这里是 1024, 所以前四个字节赋值为 1024 (既然我们要构造不定长数据包，那么这个包到底有多长呢，因此，我们就必须通过一个变量来表明这个数据包的长度，这就是 len 的作用)；而紧接其后的内存是真正的数据部分, 通过 p->data, 最后, 进行一个 memcpy() 内存拷贝, 把要发送的数据填入到这段内存当中

  • 释放：那么当使用完毕释放数据的空间的时候, 直接释放就可以了

// 销毁
free(mbuffer);
mbuffer = NULL;

2、小结:

  • 使用定长数组, 作为数据缓冲区, 为了避免造成缓冲区溢出, 数组的大小一般设为足够的空间 MAX_LENGTH, 而实际使用过程中, 达到 MAX_LENGTH 长度的数据很少, 那么多数情况下, 缓冲区的大部分空间都是浪费掉的

  • 但是使用过程很简单, 数据空间的开辟和释放简单, 无需程序员考虑额外的操作

3、 指针数据包(开辟空间, 释放, 访问):

如果你将上面的长度为 MAX_LENGTH 的定长数组换为指针, 每次使用时动态的开辟CURR_LENGTH 大小的空间, 那么就避免造成 MAX_LENGTH - CURR_LENGTH 空间的浪费, 只浪费了一个指针域的空间：

  • 数据包定义：

struct point_buffer
{
  int     len;
  char    *data;
};

  • 数据结构大小：考虑对齐, 那么数据结构的大小 >= sizeof(int) + sizeof(char *)

  • 空间分配：但是也造成了使用在分配内存时，需采用两步

// =====================
// 指针数组  占用-开辟-销毁
// =====================
///  占用    
printf("the length of struct test3:%d\n",sizeof(struct point_buffer));
///  开辟
if ((pbuffer = (struct point_buffer *)malloc(sizeof(struct point_buffer))) != NULL)
{
  pbuffer->len = CURR_LENGTH;
  if ((pbuffer->data = (char *)malloc(sizeof(char) * CURR_LENGTH)) != NULL)
  {
      memcpy(pbuffer->data, "Hello World", CURR_LENGTH);
      printf("%d, %s\n", pbuffer->len, pbuffer->data);
  }
}

首先, 需为结构体分配一块内存空间；其次再为结构体中的成员变量分配内存空间。

这样两次分配的内存是不连续的, 需要分别对其进行管理. 当使用长度为的数组时, 则是采用一次分配的原则, 一次性将所需的内存全部分配给它。

  • 释放：相反, 释放时也是一样的：

/// 销毁
free(pbuffer->data);
free(pbuffer);
pbuffer = NULL;

  • 小结：

  • - 使用指针结果作为缓冲区, 只多使用了一个指针大小的空间, 无需使用 MAX_LENGTH 长度的数组, 不会造成空间的大量浪费。

  • 但那是开辟空间时, 需要额外开辟数据域的空间, 施放时候也需要显示释放数据域的空间, 但是实际使用过程中, 往往在函数中开辟空间, 然后返回给使用者指向 struct point_buffer 的指针, 这时候我们并不能假定使用者了解我们开辟的细节, 并按照约定的操作释放空间, 因此使用起来多有不便, 甚至造成内存泄漏。

4、变长数据缓冲区(开辟空间, 释放, 访问)

定长数组使用方便, 但是却浪费空间, 指针形式只多使用了一个指针的空间, 不会造成大量空间分浪费, 但是使用起来需要多次分配, 多次释放, 那么有没有一种实现方式能够既不浪费空间, 又使用方便的呢?

GNU C 的 0 长度数组, 也叫变长数组, 柔性数组就是这样一个扩展。对于 0 长数组的这个特点，很容易构造出变成结构体，如缓冲区，数据包等等：

  • 数据结构定义：

//  0长度数组
struct zero_buffer
{
  int     len;
  char    data[0];
};

  • 数据结构大小：这样的变长数组常用于网络通信中构造不定长数据包, 不会浪费空间浪费网络流量, 因为 char data[0]; 只是个数组名, 是不占用存储空间的：

sizeof(struct zero_buffer) = sizeof(int)

  • 开辟空间：那么我们使用的时候, 只需要开辟一次空间即可

///  开辟
if ((zbuffer = (struct zero_buffer *)malloc(sizeof(struct zero_buffer) + sizeof(char) * CURR_LENGTH)) != NULL)
{
    zbuffer->len = CURR_LENGTH;
    memcpy(zbuffer->data, "Hello World", CURR_LENGTH);
    printf("%d, %s\n", zbuffer->len, zbuffer->data);
}

  • 释放空间：释放空间也是一样的, 一次释放即可

///  销毁
free(zbuffer);
zbuffer = NULL;

  • 总结：

// zero_length_array.c

#include <stdio.h>
#include <stdlib.h>
#define MAX_LENGTH      1024
#define CURR_LENGTH      512

//  0长度数组
struct zero_buffer
{
int     len;
char    data[0];
}__attribute((packed));

//  定长数组
struct max_buffer
{
int     len;
char    data[MAX_LENGTH];
}__attribute((packed));

//  指针数组
struct point_buffer
{
int     len;
char    *data;
}__attribute((packed));

int main(void)
{
    struct zero_buffer  *zbuffer = NULL;
  struct max_buffer   *mbuffer = NULL;
  struct point_buffer *pbuffer = NULL;

  // =====================
  // 0长度数组  占用-开辟-销毁
  // =====================
  ///  占用
  printf("the length of struct test1:%d\n",sizeof(struct zero_buffer));
  ///  开辟
  if ((zbuffer = (struct zero_buffer *)malloc(sizeof(struct zero_buffer) + sizeof(char) * CURR_LENGTH)) != NULL)
  {
      zbuffer->len = CURR_LENGTH;
      memcpy(zbuffer->data, "Hello World", CURR_LENGTH);
      printf("%d, %s\n", zbuffer->len, zbuffer->data);
  }  
  ///  销毁
  free(zbuffer);
  zbuffer = NULL;

  // =====================
  // 定长数组  占用-开辟-销毁
  // =====================
  ///  占用
  printf("the length of struct test2:%d\n",sizeof(struct max_buffer));
  ///  开辟
  if ((mbuffer = (struct max_buffer *)malloc(sizeof(struct max_buffer))) != NULL)
  {
      mbuffer->len = CURR_LENGTH;
      memcpy(mbuffer->data, "Hello World", CURR_LENGTH);
      printf("%d, %s\n", mbuffer->len, mbuffer->data);
  }
  /// 销毁
  free(mbuffer);
  mbuffer = NULL;

  // =====================
  // 指针数组  占用-开辟-销毁
  // =====================
  ///  占用
  printf("the length of struct test3:%d\n",sizeof(struct point_buffer));
  ///  开辟
  if ((pbuffer = (struct point_buffer *)malloc(sizeof(struct point_buffer))) != NULL)
  {
      pbuffer->len = CURR_LENGTH;
      if ((pbuffer->data = (char *)malloc(sizeof(char) * CURR_LENGTH)) != NULL)
    {
        memcpy(pbuffer->data, "Hello World", CURR_LENGTH);
      printf("%d, %s\n", pbuffer->len, pbuffer->data);
    }
  }
  /// 销毁
  free(pbuffer->data);
  free(pbuffer);
  pbuffer = NULL;
  return EXIT_SUCCESS;
}

b6ddef0b1197caf5ba710d1ff5090163.png


  • 长度为 0 的数组并不占有内存空间， 而指针方式需要占用内存空间.

  • 对于长度为 0 数组, 在申请内存空间时, 采用一次性分配的原则进行; 对于包含指针的结构体, 在申请空间时需分别进行, 释放时也需分别释放.

  • 对于长度为 0 的数组的访问可采用数组方式进行

GNU Document中 变长数组的支持：

参考：

6.17 Arrays of Length Zero
C Struct Hack – Structure with variable length array

在 C90 之前, 并不支持 0 长度的数组, 0 长度数组是 GNU C 的一个扩展, 因此早期的编译器中是无法通过编译的；对于 GNU C 增加的扩展, GCC 提供了编译选项来明确的标识出他们:

  • -pedantic 选项，那么使用了扩展语法的地方将产生相应的警告信息

  • -Wall 使用它能够使 GCC 产生尽可能多的警告信息

  • -Werror, 它要求 GCC 将所有的警告当成错误进行处理

// 1.c
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    char a[0];
  printf("%ld", sizeof(a));
  return EXIT_SUCCESS;
}

我们来编译：

# 显示所有警告
gcc 1.c -Wall
#none warning and error

# 对GNU C的扩展显示警告
gcc 1.c -Wall -pedantic
1.c: In function ‘main’:
1.c:7: warning: ISO C forbids zero-size array ‘a’

# 显示所有警告同时GNU C的扩展显示警告, 将警告用 error 显示
gcc 1.c -Werror -Wall -pedantic 
cc1: warnings being treated as errors
1.c: In function ‘main’:
1.c:7: error: ISO C forbids zero-size array ‘a’

157dab61249a3297b3f0c05194ef3efc.png


0长度数组其实就是灵活地运用数组指向的是其后面连续的内存空间：

struct buffer
{
  int     len;
  char    data[0];
};

在早期没引入 0 长度数组的时候, 大家是通过定长数组和指针的方式来解决的, 但是：

  • 定长数组定义了一个足够大的缓冲区, 这样使用方便, 但是每次都造成空间的浪费

  • 指针的方式， 要求程序员在释放空间时必须进行多次的 free 操作， 而我们在使用的过程中往往在函数中返回了指向缓冲区的指针， 我们并不能保证每个人都理解并遵从我们的释放方式。

    所以 GNU 就对其进行了 0 长度数组的扩展. 当使用 data[0] 的时候, 也就是 0 长度数组的时候，0长度数组作为数组名, 并不占用存储空间。

在 C99 之后，也加了类似的扩展，只不过用的是 char payload[] 这种形式（所以如果你在编译的时候确实需要用到 -pedantic参数，那么你可以将 char payload[0] 类型改成 char payload[] , 这样就可以编译通过了，当然你的编译器必须支持 C99 标准的，如果太古老的编译器，那可能不支持了)

// 2.c payload
#include <stdio.h>#
include <stdlib.h>

struct payload
{
    int   len;
  char  data[];
};

int main(void)
{
    struct payload pay;
  printf("%ld", sizeof(pay));
  return EXIT_SUCCESS;
}

使用 -pedantic 编译后, 不出现警告, 说明这种语法是 C 标准的

gcc 2.c -pedantic -std=c99

bddc0186cdfc3722e84b89c1f8d6284f.png


所以结构体的末尾, 就是指向了其后面的内存数据。因此我们可以很好的将该类型的结构体作为数据报文的头格式，并且最后一个成员变量，也就刚好是数据内容了.

GNU 手册还提供了另外两个结构体来说明，更容易看懂意思：

struct f1 
{
    int x;
  int y[];
} f1 = { 1, { 2, 3, 4 } };

struct f2
{
    struct f1 f1;
  int data[3];
} f2 = { { 1 }, { 5, 6, 7 } };

我把 f2 里面的 2,3,4 改成了 5,6,7 以示区分。如果你把数据打出来。即如下的信息：

f1.x = 1
f1.y[0] = 2
f1.y[1] = 3
f1.y[2] = 4

也就是 f1.y 指向的是 {2,3,4} 这块内存中的数据。所以我们就可以轻易的得到，f2.f1.y  指向的数据也就是正好 f2.data 的内容了。打印出来的数据：

f2.f1.x = 1
f2.f1.y[0] = 5
f2.f1.y[1] = 6
f2.f1.y[2] = 7

如果你不是很确认其是否占用空间. 你可以用 sizeof 来计算一下。就可以知道 sizeof(struct f1)=4,也就是 int y[]其实是不占用空间的。但是这个 0 长度的数组，必须放在结构体的末尾。如果你没有把它放在末尾的话。编译的时候，会有如下的错误：

main.c:37:9: error: flexible array member not at end of struct
                    int y[];
                            ^

到这边，你可能会有疑问，如果将 struct f1 中的 int y[] 替换成 int *y ，又会是如何？这就涉及到数组和指针的问题了. 有时候吧，这两个是一样的，有时候又有区别。

首先要说明的是，支持 0 长度数组的扩展，重点在数组，也就是不能用 int *y 指针来替换。sizeof 的长度就不一样了。把struct f1 改成这样：

struct f3
{
    int x;
  int *y;
};

在 32/64 位下, int 均是 4 个字节,  sizeof(struct f1)=4，而 sizeof(struct f3)=16

因为int *y 是指针, 指针在 64 位下, 是 64 位的， sizeof(struct f3) = 16；如果在32位环境的话, sizeof(struct f3) 则是 8 了, sizeof(struct f1) 不变. 所以 int *y 是不能替代 int y[] 的;

代码如下:

// 3.c
#include <stdio.h>
#include <stdlib.h>

struct f1
{
    int x;
  int y[];
} f1 = { 1, { 2, 3, 4 } };

struct f2 
{
    struct f1 f1;
  int data[3];
} f2 = { { 1 }, { 5, 6, 7 } };

struct f3
{
    int x;
  int *y;
};

int main(void)
{
    printf("sizeof(f1) = %d\n", sizeof(struct f1));
  printf("sizeof(f2) = %d\n", sizeof(struct f2));
  printf("szieof(f3) = %d\n\n", sizeof(struct f3));

  printf("f1.x = %d\n", f1.x);
  printf("f1.y[0] = %d\n", f1.y[0]);
  printf("f1.y[1] = %d\n", f1.y[1]);
  printf("f1.y[2] = %d\n", f1.y[2]);

  printf("f2.f1.x = %d\n", f1.x);
  printf("f2.f1.y[0] = %d\n", f2.f1.y[0]);
  printf("f2.f1.y[1] = %d\n", f2.f1.y[1]);
  printf("f2.f1.y[2] = %d\n", f2.f1.y[2]);

  return EXIT_SUCCESS;
}

a29b74103898aed5c8d44d4082f68cbd.png


0 长度数组的其他特征:

1、为什么 0 长度数组不占用存储空间:

0 长度数组与指针实现有什么区别呢, 为什么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]本质上是否有区别？我们可以通过一个例子来说明。

参见如下两个程序 gdb_zero_length_array.c和 gdb_zero_length_array.c：

//  gdb_zero_length_array.c
#include <stdio.h>
#include <stdlib.h>

struct str
{
    int len;
  char s[0];
};

struct foo
{
    struct str *a;
};

int main(void)
{
    struct foo f = { NULL };
  printf("sizeof(struct str) = %d\n", sizeof(struct str));
  printf("before f.a->s.\n");
  if(f.a->s)
  {
      printf("before printf f.a->s.\n");
    printf(f.a->s);
    printf("before printf f.a->s.\n");
  }

  return EXIT_SUCCESS;
}

\

40b53db9bc21b2d61f95abeea1f4c871.png


//  gdb_pzero_length_array.c
#include <stdio.h>#
include <stdlib.h>

struct str
{
    int len;
  char *s;
};

struct foo
{
    struct str *a;
};

int main(void)
{
    struct foo f = { NULL };
  printf("sizeof(struct str) = %d\n", sizeof(struct str));
  printf("before f.a->s.\n");

  if (f.a->s)
  {
      printf("before printf f.a->s.\n");
    printf(f.a->s);
    printf("before printf f.a->s.\n");
  }

    return EXIT_SUCCESS;
}

76a62f59e564d3f779492332b6f6956d.png


可以看到这两个程序虽然都存在访问异常, 但是段错误的位置却不同

我们将两个程序编译成汇编, 然后 diff 查看他们的汇编代码有何不同

gcc -S gdb_zero_length_array.c -o gdb_test.s
gcc -S gdb_pzero_length_array.c -o gdb_ptest
diff gdb_test.s gdb_ptest.s

1c1
<   .file   "gdb_zero_length_array.c"
---
>   .file   "gdb_pzero_length_array.c"
23c23
<   movl    $4, %esi
---
>   movl    $16, %esi
30c30
<   addq    $4, %rax
---
>   movq    8(%rax), %rax
36c36
<
addq    $4, %rax
---
>   movq    8(%rax), %rax  # printf("sizeof(struct str) = %d\n", sizeof(struct str));
23c23
<   movl    $4, %esi      #printf("sizeof(struct str) = %d\n", sizeof(struct str));
---
>   movl    $16, %esi     #printf("sizeof(struct str) = %d\n", sizeof(struct str));

从 64 位系统中, 汇编我们看出, 变长数组结构的大小为 4, 而指针形式的结构大小为 16：

f.a->s
30c30/36c36
<   addq    $4, %rax
---
>   movq    8(%rax), %rax

可以看到有：

  • 对于 char s[0] 来说, 汇编代码用了 addq 指令, addq $4, %rax

  • 对于 char *s 来说，汇编代码用了 movq 指令, movq 8(%rax), %rax

addq 对 %rax + sizeof(struct str), 即 str 结构的末尾即是 char s[0] 的地址, 这一步只是拿到了其地址, 而 movq 则是把地址里的内容放进去, 因此有时也被翻译为 leap 指令, 参见下一例子

从这里可以看到, 访问成员数组名其实得到的是数组的相对地址, 而访问成员指针其实是相对地址里的内容(这和访问其它非指针或数组的变量是一样的)：

  • 访问相对地址，程序不会 crash，但是，访问一个非法的地址中的内容，程序就会 crash。

// 4-1.c
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    char *a;
  printf("%p\n", a);
  return EXIT_SUCCESS;
}


4-2.c
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    char a[0];
  printf("%p\n", a);    return EXIT_SUCCESS;
}


$ diff 4-1.s 4-2.s
1c1
<       .file   "4-1.c"
---
>       .file   "4-2.c"
13c13
<       subl    $16, %esp
---
>       subl    $32, %esp
15c15
<       leal    16(%esp), %eax
---
>       movl    28(%esp), %eax

  • 对于 char a[0] 来说, 汇编代码用了 leal 指令, leal 16(%esp), %eax：

  • 对于 char *a 来说，汇编代码用了 movl 指令, movl 28(%esp), %eax

2、地址优化:

// 5-1.c
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    char a[0];
  printf("%p\n", a);

  char b[0];
  printf("%p\n", b);

  return EXIT_SUCCESS;
}

90ad4a9ce34dea36ee0fc899b5585a16.png

img

由于 0 长度数组是 GNU C 的扩展, 不被标准库任可, 那么一些巧妙编写的诡异代码, 其执行结果就是依赖于编译器和优化策略的实现的.

比如上面的代码, a 和 b 的地址就会被编译器优化到一处, 因为 a[0] 和 b[0] 对于程序来说是无法使用的, 这让我们想到了什么?

编译器对于相同字符串常量, 往往地址也是优化到一处, 减少空间占用：

//  5-2.c
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    const char *a = "Hello";
  printf("%p\n", a);

  const char *b = "Hello";
  printf("%p\n", b);

  const char c[] = "Hello";
  printf("%p\n", c);

  return EXIT_SUCCESS;
}

6ac2cdf39d8e8156fb4d3bd570424270.png

*声明：本文于网络整理，版权归原作者所有，如来源信息有误或侵犯权益，请联系我们删除或授权事宜。

9bf6d0a62465794f4c82994447af1ca4.png

f799d01bd986e4b65af37496aacf8bf4.gif

戳“阅读原文”我们一起进步

轻松学C语言
关注
万字总结八大排序算法（图文详解）
oorik的博客
11-26 7323
文章目录 1.冒泡排序 2.选择排序 3.插入排序 4.归并排序 5.快速排序 一、冒泡排序 基本思想： 在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。每一趟排序后的效果都是讲没有沉下去的元素给沉下去。 主要思路: 1.比较相邻的元素。如果第一个比第二个大，...
C - 零长度数组
pqb777的博客
12-10 426
最近在看代码有看到变长数组的应用，这里整合了两篇比较好的变长数组的文章分享给大家，文章链接见文末。 零长度数组 零长度数组，顾名思义，就是长度为0的数组。 ANSI C 标准规定：定义一个数组时，数组的长度必须是一个常数，即数组的长度在编译的时候是确定的。在ANSI C 中定义一个数组的方法如下： int a[10]; C99 新标准规定：可以定义一个变长数组。 int len; int a[len]; 也就是说，数组的长度在编译时是未确定的，在程序运行的时候才确定，甚至可以由用户指定大小。 比如，我
浅析长度为0的数组
weixin_33720956的博客
10-08 344
2019独角兽企业重金招聘Python工程师标准>>> ...
C语言：长度为0的数组
zzy570384336的博客
10-12 492
概述 长度为0的数组在标准c和c++中是不合法的，但是在gcc中是可行的。 长度为0数组它的最典型的用法就是位于结构体中的最后一项。 使用方式 如下面的例子，分别使用长度为0的数组和指针声明结构体，实现可变长度的数组功能： #include <stdio.h> #include <stdlib.h> struct test1 { int a; int b[0]; }; struct test2 { int a; int *b; }; struct
C语言中长度为0的数组
u011029104的专栏
01-29 1058
前面在看Xen的源码时，遇到了一段代码，如下所示： 注意上面最后一行的代码，这里定义了一个长度为的数组，这种用法可以吗？为什么可以使用长度为0的数组？长度为的数组到底怎么使用？……这篇文章主要针对该问题进行简单的讲解。废话不多说了，现在就开始。 长度为的数组在标准c和c++中是不允许的，如果使用长度为的数组，编译时会产生错误，提示数组长度不能为。但在GNUc中，这种用法却是合法的。它的最典型的用法就是位于数组中的最后一项，如上面所示，这样做主要是为了方便内存缓冲区的管理。如果你将上面的长度为的.
c语言中长度为0的数组妙用
Y___Y的专栏
01-06 5312
c语言中长度为0的数组妙用长度为0的数组在GNU C是可以使用的，在定义一个变长对象的结构体是非常有用的。请看下例。struct line {int length;char contents[0];};struct line *thisline = (struct line *)malloc (sizeof (struct line) + this_length);thisline->length
C语言-数据在内存中的存储（万字详解）
Yzffff的博客
05-30 435
带你了解整型浮点型是怎样在内存中存储的，以及它们如何取出来
【C语言】操作符大全万字详解
我的主页
11-15 3819
本期讲解：原码、反码、补码的计算，以及各种操作符的运算规则，如+、-、*、/、%、&、*、|、[]、()、等等，最后还附有优先级从高到低的表格参考。
✨三万字制作，关于C语言，你必须知道的这些知识点（高阶篇）✨
热门推荐
耀的博客
10-05 2万+
一，写在前面 说实话，我上一篇写的基础篇能上全站热搜榜一，真的是诚惶诚恐，觉得自己配不上这个榜一，分享内容其实没那么好，得到C站的朋友的认可，有点小开心，这会更加督促我提升自己的水平，提升自己博客的质量，对的起大家的认可。 上一篇讲的是基础，这篇讲的是高阶版，需要多练习多揣摩，还是那句老话，如果你认为这篇博客写的不错的话，求评论，求收藏，求点赞，您的三连是我最大的制作动力，废话不多说，让我们学起来吧！！！ 二，数据的存储 1，数据类型介绍 char //字符数据类型 short
万字详解决策树之ID3、CART、C4.5【原理+实例+代码实现】
雷恩Layne
07-27 2620
文章目录决策树的含义(信息熵+信息增益)&ID3(纯度+基尼系数)&CART信息增益率&C4.5各种决策树比较与总结决策树编程实战调用sklearn库实现回归决策树手动实现ID3决策树使用sklearn库回归决策树预测boston房价使用sklearn库分类决策树对iris分类 决策树的含义 首先我们先来了解下什么是决策树。 上图就是一颗带有决策的树，其中天气、温度等称为特征，后面问号的位置称为阈值，如温度=35°，则阈值为35。 决策树是一种基本的分类与回归方法。这里主要讨论决
零长度数组的妙用
weixin_30758821的博客
04-19 133
零长度是指定义数组时，指定其长度为0（如int arr[0];)，这样的数组不占用实际的空间，但能通过数组名访问到其指向的地址。如下例所示： #include <stdlib.h>#include <stdio.h>struct device{int num;int count; int reserve[0]; /* * reserve是一个...
C语言技巧之长度为0的数组
择一事终一生
07-03 477
qiuliangflash2013-04-10 23:53:51©著作权 在gnu c中有一种用法，就是可以使用长度为0的数组，比如说一下这个结构体： struct sample { int length; char store[0]; } 可以像以下这种方式来使用： struct sample * example = （struct sample *)malloc(sizeof(struct sample)+size); example->length = size; exam..
C的0长数组
authorlcy的专栏
08-01 515
一、零长数组     在标准 C 或者 C++ 中由于不支持 0 长度的数组，所以 int array[0]; 这样的定义是非法的。不过有些编译器(如GCC)的扩展功能支持 0 长度的数组。     在 C 中，0 长度的数组的主要用途是用来作为结构体的最后一个成员，
C语言 0长度数组/柔性数组
a只如初见的博客
07-22 2291
零长度数组就是长度为0的数组。ANSIC标准规定定义一个数组时，数组的长度必须是一个常数，即数组的长度在编译的时候是确定的。在ANSIC中定义一个数组的方法如下类型数组名[数组元素个数];例如C99新标准规定可以定义一个变长数组。C语言的变长数组）intlen;也就是说，数组的长度在编译时是未确定的，在程序运行的时候才确定，甚至可以由用户指定大小。比如，我们可以定义一个数组，然后在程序运行时才指定这个数组的大小，还可以通过输入数据来初始化数组。.........
C语言0长度数组(可变数组/柔性数组)
最新发布
weixin_42884925的博客
06-05 684
Linux内核编程时常用的likely（）和unlikely（）底层调用的likely_notrace（）、unlikely_notrace（）就是基于 __builtin_expect（EXP，C）实现的。内建函数__builtin_return_address（LEVEL）返回当前函数或其调用者的返回地址，参数LEVEL指定调用栈的级数，如0表示当前函数的返回地址，1表示当前函数的调用者的返回地址。GNU C把包含在括号中的复合语句看成是一个表达式，称为语句表达式，它可以出现在任何允许表达式的地 方。
C语言中的0长数组
yaoyuantao的博客
04-14 1062
0长数组是数据结构中很特殊的存在，文章介绍了0长数组的用法和其与指针的区别及优势
长度为0的数组妙用
weixin_42953467的博客
03-28 600
首先，长度为0的数组适用于对内存资源要求严格且数据结构繁多的场景。 1，结构变量声明为指针类型，则指针本身占用4字节，且需要额外申请，额外释放。 2，结构变量申请size为0的数组不占用内存，且可以保持内存连续，统一释放即可。 例如： typedef struct { /结构头/ HEADER UINT_32 x :1; UINT_32 y :1; UINT_32 z :30; UI...
结构体中最后一个成员为[0]或[1]长度数组(柔性数组成员)的用法
架构设计
04-20 808
结构体中最后一个成员为[0]长度数组的用法：这是个广泛使用的常见技巧，常用来构成缓冲区。比起指针，用空数组有这样的优势：(1)、不需要初始化，数组名直接就是所在的偏移；(2)、不占任何空间，指针需要占用int长度空间，空数组不占任何空间。“这个数组不占用任何内存”，意味着这样的结构节省空间；“该数组的内存地址就和它后面的元素地址相同”，意味着无需初始化，数组名就是后面元素的地址，直接就能当指针使用...
c语言之零长度数组
进步源于记录，优秀来自分享
08-26 346
我们设想这样一个场景, 我们在网络通信过程中使用的数据缓冲区, 缓冲区包括一个len字段和data字段, 分别标识数据的长度和传输的数据, 我们常见的有几种设计思路 1、定长数据缓冲区, 设置一个足够大小 MAX_LENGTH 的数据缓冲区 2、设置一个指向实际数据的指针, 每次使用时, 按照数据的长度动态的开辟数据缓冲区的空间. 对于第一种，很明显会出现空间的浪费，比如实际buffer大小...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值