C语言0长度数组(可变数组/柔性数组)详解

article/2025/8/30 9:32:15
CSDNGitHub
C语言0长度数组(可变数组/柔性数组)详解AderXCoding/language/c/zero_length_array


知识共享许可协议
本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可, 转载请注明出处, 谢谢合作

1 零长度数组概念

众所周知, 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的数组必须在最后声明，使 用上有一定限制。

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

2 0长度数组的用途

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

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

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

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

2.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;

  • 小结

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

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

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

如果你将上面的长度为 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);}}

  1. 首先, 需为结构体分配一块内存空间;

  2. 其次再为结构体中的成员变量分配内存空间.

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

  • 释放

相反, 释放时也是一样的.

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

  • 小结

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

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

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

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

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;

2.4 总结

// 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;
}

运行结果

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

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

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

3 GNU Document中 变长数组的支持

参见

6.17 Arrays of Length Zero

C Struct Hack – Structure with variable length array

在 C90 之前, 并不支持0长度的数组, 0长度数组是 GNU C 的一个扩展, 因此早期的编译器中是无法通过编译的

对于 GNU C 增加的扩展, GCC 提供了编译选项来明确的标识出他们

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

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

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

运行结果

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

2

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

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;
}

运行结果

4 0长度数组的其他特征

4.1 为什么0长度数组不占用存储空间

参见

结构体中的指针与零长度数组

GNU C中的零长度数组

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;
}

测试结果

//  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;
}

测试结果

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

我们将两个程序编译成汇编, 然户 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

4.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;
}

5

由于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;
}

5-2

参考

结构体中的指针与零长度数组

零长度数组的妙用

C语言中长度为0的数组

C/C++ 中的0长数组（柔性数组）

GNU C中的零长度数组

C语言变长数组data[0]【总结】

长度为0的数组——C语言的非标准用法之一

长度为0的数组的size为什么不一定是0？

有关C语言占位符

C语言技巧之长度为0的数组

零长度数组使用

使用零长度数组

零长度数组

C/C++ 中长度为0的数组

GCC 中零长数组与变长数组

零长度数组的妙用

Multiple 0-length arrays have the same address?



知识共享许可协议本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可, 转载请注明出处, 谢谢合作.


http://chatgpt.dhexx.cn/article/mMaybYgI.shtml

相关文章

C语言的数组长度能用变量指定吗？

C语言的数组长度能用变量指定吗？

疑问&#xff1a;C语言的数组长度能用变量指定吗&#xff1f; 回答&#xff1a;在支持C99的编译器下可以。 一、背景简介 C89/C90&#xff1a; C89即ANSI C&#xff0c;ANSI&#xff1a;美国国家标准学会&#xff08;American Natinal Standards Institute&#xff09;C90即I…
阅读更多...
空间平面及其方程

空间平面及其方程

目录 1. 方程类型2. 常见问题 F&#xff08;x&#xff0c;y&#xff0c;z&#xff09; 0 几何意义 空间中的平面 1. 方程类型 点法式 A&#xff08;x - x0&#xff09; B&#xff08;y - y0&#xff09; C&#xff08;z - z0&#xff09; 0 &#xff08;A&#xff0c;B&am…
阅读更多...
三维空间平面拟合MATLAB

三维空间平面拟合MATLAB

1.根据一组点的坐标拟合空间平面&#xff0c;有两种方法&#xff1a; 第一种&#xff1a;如果在测量得到的数据中&#xff0c;x&#xff0c;y值都是确认没有误差的&#xff0c;而误差只是出现在z值上&#xff0c;则可以使用线性回归的方法&#xff0c;此方法最小二乘的目标是在…
阅读更多...
空间曲面构造及其方程

空间曲面构造及其方程

&#xff11;.旋转单叶双曲面 旋转单叶双曲面是直纹面&#xff0c;它的构造有多种方式&#xff0c;先看其中一种: 设直线的参数方程为&#xff1a; 则通过geogebra命令 bCurve(1,t,2t,t,-5,5) 绘制出的直线如图所示&#xff0c;它将作为旋转单叶双曲面的&#xff02;直纹&quo…
阅读更多...
三维空间：点到线的距离，点到面上的投影，直线在平面上的投影直线方程（平面束）

三维空间：点到线的距离，点到面上的投影，直线在平面上的投影直线方程（平面束）

你好哦&#xff0c;这里是云切月斩&#xff08;Echo_Fish&#xff09;&#xff0c;本文章如果能加深你对于高等数学知识点的理解&#xff0c;那么我将不胜荣幸&#xff01;如果本文章存在错误请不吝赐教&#xff01; 一、点到线的距离&#xff08;已知一个点和直线的一般式&…
阅读更多...
0803平面及其方程-向量代数与空间解析几何

0803平面及其方程-向量代数与空间解析几何

文章目录 1 曲面方程与空间曲线方程的概念1.1 曲面方程1.2 空间曲线的方程 2 平面的点法式方程3 平面的一般方程4 两平面的夹角4.1 两平面夹角的定义4.2 夹角的余弦公式4.3 点到平面的距离 结语 1 曲面方程与空间曲线方程的概念 1.1 曲面方程 如果曲面与三元方程 ​ F ( x …
阅读更多...
空间解析几何中那些图形和方程（大彻大悟版）

空间解析几何中那些图形和方程（大彻大悟版）

文章目录 前言一、平面及其方程平面的点法式方程平面的一般方程平面的截距式方程两平面的夹角点到平面的距离公式 二、空间直线及其方程空间直线的一般方程空间直线的对称式方程&#xff08;点向式方程&#xff09;空间直线的参数方程两直线的夹角直线与平面的夹角平面束方程 三…
阅读更多...
平面方程

平面方程

平面方程 原文链接&#xff1a; http://www.songho.ca/math/plane/plane.html 飘飘白云 译( http://www.cnblogs.com/kesalin) (转载请注明出处以及作&译者信息&#xff0c;非商业用途) 平面方程 平面上的一点以及垂直于该平面的法线唯一定义了 3D 空间的一个平面。 (图一)…
阅读更多...
空间解析几何 | 平面束方程及其应用

空间解析几何 | 平面束方程及其应用

一、对直线在平面上的另一种描述。 二、 平面束及其方程。 三、 求空间直线在平面上的投影方程。 求满足一定条件的平面方程。&#xff08;注意&#xff01;这个解答是不完整的&#xff01;&#xff09; 摘录 https://jingyan.baidu.com/article/3c48dd34cfdec1e10be358f5.htm…
阅读更多...
已知空间一点和法向量，如何计算空间平面方程

已知空间一点和法向量，如何计算空间平面方程

2018-01-18 创建人&#xff1a;Ruo_Xiao 邮箱&#xff1a;xclsoftware163.com法向量N&#xff1a; 点P&#xff1a; 平面方程&#xff1a;
阅读更多...
已知三点空间直角坐标求空间平面方程

已知三点空间直角坐标求空间平面方程

已知三点p1&#xff08;x1,y1,z1&#xff09;&#xff0c;p2(x2,y2,z2)&#xff0c;p3(x3,y3,z3)&#xff0c;要求确定的平面方程 关键在于求出平面的一个法向量&#xff0c;为此做向量p1p2&#xff08;x2-x1,y2-y1,z2-z1), p1p3(x3-x1,y3-y1,z3-z1),平面法线和这两个向量垂直…
阅读更多...
三维空间中的平面方程

三维空间中的平面方程

平面方程&#xff1a; AxByCzD0 (参数,A,B,C,D是描述平面空间特征的常数) 如何求参数&#xff1a; 选择逆时针凸多边形的三个连续顶点(x1,y1,z1),(x2,y2,z2),(x3,y3,z3) 建立方程组来求A,B,C,D&#xff08;为什么要选择凸多边形(暂时没想明白)&#xff09; 具体解法&#xf…
阅读更多...
空间中平面方程求解及点到平面的距离

空间中平面方程求解及点到平面的距离

1.空间中平面方程的一般形式为&#xff1a; AxByCzD0 (参数,A,B,C,D是描述平面空间特征的常数) 已知空间中3个点的坐标(x1,y1,z1),(x2,y2,z2),(x3,y3,z3)&#xff0c;求解平面方程。 解法1.根据已知的3个点&#xff0c;建立3个联合方程组&#xff0c;进行消元&#xff1b…
阅读更多...
三维空间平面方程

三维空间平面方程

已知空间中三点&#xff0c;求平面方程&#xff1a; 三点坐标&#xff1a;(x1,y1,z1),(x2,y2,z2),(x3,y3,z3) 待求平面方程&#xff1a;AxByCzD0 求解公式&#xff1a; 平面法向量为&#xff08;A,B,C&#xff09; 空间坐标原点到平面的距离为D Matlab代码&#xff1a; %%%求…
阅读更多...
空间平面方程的三种表述方式

空间平面方程的三种表述方式

一、一般式 任意的空间平面都可以表示一般形式&#xff1a; 二、点法式 假设&#xff0c;已知空间平面的法向量以及平面上的任意一点&#xff1a; 则该空间平面可以表述为&#xff1a; 三、三点确定一个空间平面 假设&#xff0c;已知空间平面上的三个不共线的空间点 则该空间平…
阅读更多...
线代基础

线代基础

矩阵&#xff1a; 加减乘除(除法表现为矩阵的逆) 单位矩阵&#xff1a; 矩阵的逆&#xff1a; R2空间矩阵的逆&#xff1a; Rn空间矩阵的逆&#xff1a; 求法比较简单的为消元法&#xff0c;其他都比较复杂。 高斯消元法求矩阵的逆&#xff1a; 通过矩阵的逆求解方程组&a…
阅读更多...
随机网络和无标度网络

随机网络和无标度网络

传统的随机网络&#xff08;如ER模型&#xff09;&#xff0c;尽管连接是随机设置的&#xff0c;但大部分节点的连接数目会大致相同&#xff0c;即节点的分布方式遵循钟形的泊松分布&#xff0c;有一个特征性的“平均数”。连接数目比平均数高许多或低许多的节点都极少&#xf…
阅读更多...
级联失效matlab,加权无标度网络的级联失效模型

级联失效matlab,加权无标度网络的级联失效模型

社交网、交通网、通信网等领域均呈现无标度特性[, 是复杂网络中常见的一种现象, 不同网络中的节点和边都承载着不同形式的负载, 且负载的承受能力是有限的.加权无标度网络是指节点和边根据权值构建成的网络[, 应用在专家网等领域. 在复杂网络中, 节点和边承担的负载是不断演化的…
阅读更多...
复杂网络-无标度网络matlab代码实现

复杂网络-无标度网络matlab代码实现

无标度网络是进入研究生&#xff0c;导师丢来的第一个作业&#xff0c;从本科的小小程序猿进入这种乍看一眼非常高大上的东西&#xff0c;还是有些恐惧和兴奋的。 由于没找到中文版的 Emergence of Scaling in Random Networks 就借助Google翻译&#xff0c;糙糙看了一下&…
阅读更多...
常见网络模型——BA无标度网络（使用轮盘赌算法）（python）

常见网络模型——BA无标度网络（使用轮盘赌算法）（python）

之前记录了一下&#xff0c;常见的四种网络模型——ER、BA、WS、规则图&#xff0c;以及如何使用python实现&#xff0c;具体请移步&#xff1a; https://blog.csdn.net/un357951/article/details/103514682 当时因为对轮盘赌算法还不熟悉&#xff0c;所以没有把轮盘赌算法和…
阅读更多...
推荐文章

Copyright @ 2022~2023