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

点击蓝字

d97c20799e56a203640f549412a94998.png

关注我们

零长度数组概念:

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

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

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

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

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

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

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

注意 :如果结构体是通过 callocmalloc 或 者 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 structint 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.s1c1
<   .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

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

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/337580.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

app访问java web_Java Web App体系结构

app访问java web我曾经利用Servlet&#xff0c;JSP&#xff0c;JAX-RS&#xff0c;Spring框架&#xff0c;Play框架&#xff0c;带有Facelets的JSF和一些Spark框架。 以我的拙见&#xff0c;所有这些解决方案都远非面向对象和优雅的。 它们都充满了静态方法&#xff0c;不可测试…

电路中滤波电容和退耦电容_详解电源滤波电路中的高频滤波电容电路

图2-12所示是电源滤波电路中的高频滤波电路。电路中&#xff0c;一个容量很大的电解电容C1(2200F)与一个容量很小的电容C2(0.01F)并联&#xff0c;C2是高频滤波电容&#xff0c;用来进行高频成分的滤波&#xff0c;这种一大一小两个电容相并联的电路在电源电路中十分常见。1.高…

计算机驱动空间不够,Win8.1系统如何释放驱动器空间解决可用空间不足问题

现在越来越多用户安装升级win8.1系统&#xff0c;在操作使用过程中难免遇到一些奇奇怪怪的问题。相信有很多win8.1系统用户会遇到电脑的可用空间不足的提示&#xff0c;用户感到很疑惑&#xff0c;自己的电脑又没装什么软件怎么会这么提示。有什么办法可以解决此问题&#xff0…

C/C++ 中公认的三个难点

点击蓝字关注我们C语言在嵌入式学习中是必备的知识&#xff0c;审核大部分操作都要围绕C语言进行&#xff0c;而其中有三块“难啃的硬骨头”几乎是公认级别的。0x01 指针指针公认最难理解的概念&#xff0c;也是让很多初学者选择放弃的直接原因。指针之所以难理解&#xff0c;因…

python 字符串分割_如何使用python语言split方法对不同字符串分割

在JavaScript中&#xff0c;可以使用split()将字符串分割成字符串数组&#xff1b;而在python语言中&#xff0c;split()方法也可以将字符串进行分割&#xff0c;分割之后的结果放置在列表中。下面利用几个实例说明split()方法的用法&#xff0c;操作如下&#xff1a;工具/原料…

java 拼图_功能项目拼图将Java 9引入

java 拼图因此&#xff0c;拼图项目...我们已经对此颇为了解&#xff0c;但尚未看到计划如何兑现其承诺的细节。 这篇文章将精确地做到这一点&#xff0c;并介绍项目的核心概念和功能。 系列 这篇文章是正在进行的有关拼图项目系列的一部分。 按照推荐的顺序&#xff08;不同于…

win7 蓝牙4.0 ble驱动_初识物联网无线通信技术之蓝牙4.0BLE协议栈

[本文属原创&#xff0c;转载请附上原文出处链接。]一、需要的软件工具1、BLE协议栈(BLE-CC254x-1.4.0)2、IAR开发软件(IAR Embedded Workbench8.20.2)注&#xff1a;1.4.0协议栈使用8.20.2的iar版本&#xff0c;1.3.2协议栈等使用的是8.10.4的iar版本。二、BLE协议栈安装目录下…

C语言:谈谈指针!

点击蓝字关注我们指针对于C来说太重要。然而&#xff0c;想要全面理解指针&#xff0c;除了要对C语言有熟练的掌握外&#xff0c;还要有计算机硬件以及操作系统等方方面面的基本知识。所以本文尽可能的通过一篇文章完全讲解指针。为什么需要指针&#xff1f;指针解决了一些编程…

C/C++ 中的 #pragma once 作用是什么?

点击蓝字关注我们1、#pragma once有什么作用&#xff1f;为了避免同一个头文件被包含&#xff08;include&#xff09;多次&#xff0c;C/C中有两种宏实现方式&#xff1a;一种是#ifndef方式&#xff1b;另一种是#pragma once方式。在能够支持这两种方式的编译器上&#xff0c;…

python做大数据的框架_Python+大数据计算平台,PyODPS架构手把手教你搭建

原文链接&#xff1a;http://click.aliyun.com/m/13965/ 在2016年10月的云栖社区在线培训上&#xff0c;来自阿里云大数据事业部的秦续业分享了《双剑合壁——Python和大数据计算平台的结合实战》。他主要介绍了数据分析和机器学习的方法、DataFrame整体架构以及基础API、前端、…

武魂觉醒s系列服务器,[多线]星河斗罗——新服开荒丨高程度剧情还原丨3D坐骑丨魂环丨武魂觉醒[1.12.2]...

[服务器介绍]星河斗罗 全新原创开荒斗罗大陆服务器前言&#xff1a;超高还原小说真实性&#xff0c;独特的武魂贴图&#xff0c;魂兽建模&#xff0c;坐骑建模&#xff0c;开放性冒险地图&#xff0c;让您更加体验斗罗大陆的真实性。进服送新手大礼包&#xff1a;装备&#xff…

C++ 的万能头文件,你知道多少?

点击蓝字关注我们C 中万能头文件 bits/stdc.h 的介绍很多小伙伴估计看有的代码会碰见没有多余的其它头文件比如 algorithm、cmath、iostream 而是用了一行 #include<bits/stdc.h> 这样的头文件并感到诧异&#xff0c;想这是什么。其实这是一个包含了 C 所有头文件的一个头…

pytorch dataset读取数据流程_高效 PyTorch :如何消除训练瓶颈

加入极市专业CV交流群&#xff0c;与 10000来自港科大、北大、清华、中科院、CMU、腾讯、百度 等名校名企视觉开发者互动交流&#xff01;同时提供每月大咖直播分享、真实项目需求对接、干货资讯汇总&#xff0c;行业技术交流。关注 极市平台 公众号 &#xff0c;回复 加群&…

APP 文档服务器,app服务器

app服务器 内容精选换一换华为云帮助中心&#xff0c;为用户提供产品简介、价格说明、购买指南、用户指南、API参考、最佳实践、常见问题、视频帮助等技术文档&#xff0c;帮助您快速上手使用华为云服务。调用接口出错后&#xff0c;将不会返回结果数据。调用方可根据每个接口对…

需求最高的8种编程语言

点击蓝字关注我们在过去的 8 个月时间里&#xff08;从 2021 年 10 月到 2022 年 6 月&#xff09;&#xff0c;DevJobsScanner 分析了超过 700 万份开发者工作需求&#xff0c;得出了目前行业需求量最高的 8 种编程语言。需要注意的是&#xff0c;在这 700 万份工作需求中&…

java面包屑实现_在Java中实现过滤器和面包店锁

java面包屑实现为了了解锁的工作原理&#xff0c;实现自定义锁是一种好方法。 这篇文章将展示如何在Java上实现Filter和Bakery锁&#xff08;自旋锁&#xff09;&#xff0c;并将它们的性能与Java的ReentrantLock进行比较。 过滤器锁和面包房锁满足互斥并且也是无饥饿算法&…

postman 怎么调试pos_SpringBoot|第十五章:基于Postman的RESTful接口测试

前言从上一章节开始&#xff0c;接下来的几个章节会讲解一些开发过程中配套工具的使用。俗话说的好&#xff0c;工欲善其事&#xff0c;必先利其器。对于开发人员而言&#xff0c;有个好用的工具&#xff0c;也是一件事半功倍的事&#xff0c;而且开发起来也很爽&#xff0c;效…

这几个C语言关键字你真的得懂(深度解剖)

点击蓝字关注我们1、什么是语句&#xff0c;表达式&#xff1f; 在C语言中 &#xff0c;凡是以分号隔开的就是一条语句&#xff1a;printf("hello world\n");a 1 2; ; (空语句)什么是表达式呢&#xff1f;C语言中&#xff0c;用各种操作符把变量连起来&#xff0c;…

aws sqs_JMS和AWS SQS的更多高级内容

aws sqs如您所知&#xff0c; AWS中的SQS SQS代表“简单队列服务”。 最近&#xff0c;在使用它的同时&#xff0c;我发现了将其称为“简单”的原因之一。 在之前的两篇文章&#xff08; 此处和此处 &#xff09;中&#xff0c;我展示了结合Spring Framework将SQS用作JMS队列提…

python 直方图每个bin中的值_【Python数据分析】四级成绩分布 -matplotlib,xlrd 应用...

标签&#xff1a; 最近获得了一些四级成绩数据&#xff0c;大概500多个&#xff0c;于是突发奇想是否能够看看这些成绩数据是否满足所谓的正态分布呢&#xff1f;说干就干&#xff0c;于是有了这篇文章。 文章顺带介绍了xlrd模块的一些用法和matplotlib画自定义数据的条形图和随…