如何打开 char x 3 空间

char *str[3];

这是一个指向 char 类型的指针数组，数组大小为 3，即 str[0]、str[1] 和 str[2] 都是指针，它们都指向 char 空间。

这样一来，str[1][1]这种访问是非法的。

char （*p)[3];

这是指向 char[3] 空间的指针。

使用以下命令：char （*p）[3];

p = (char (*3])malloc(3);

p[0][0] = 'a';

p[0][1] = 'b';

p[0][2] = 0;strcpy（p[0]，"ab")

printf("%s", p[0]);

free(p);

不知道解释是否令人满意？

我之前说的不是真的。

不能为数组指针赋值，因为默认情况下数组指针 str 为 const 类型。

例如： 变量定义为：

char *str[3];

它可以是这样的：str[0] = malloc（sizeof（char[3]）））。

str[1] = ..

不知道解释是否令人满意？

X-length 表面的长度是一样的，strlen 也是如此。

但是 x 会自动添加一个 0 作为字符串的终止符，因此它在内存中比 y 长。

x 是一个字符串，末尾有它'\0'

y 是字符数组。

两者不容易比较。

从内存的角度来看，x 有 5 个元素，占用 6 个字节。

y 中存储了 5 个元素，占用 5 个字节。

char x=”12345”;这么久...编译系统会自动附加一个字符串结尾。

char rp[100] 定义了一个 100 个字符的数组，在编译或运行程序时分配了 100 个字符空间。

char *rp;定义一个指向字符的指针，当程序编译或运行时，它会分配一个指针空间，在 32 台机器上通常为 4 个字节。

也可以合理地说，自动分配也是有争议的。

在空间分配方面，这就是内存管理。

通常有两种情况，一种是静态分配，由编译器和系统自动分配

正如我们通常定义的那样，int a; 这也分为两种情况。

如果 int a; 定义为全局变量，则 a 将位于系统为程序分配的空间中。

如果 int a; 在函数中定义，则 a 将位于程序的堆栈中。

另一种是动态分配，程序在运行时向系统请求内存操作。 主要目的是更好、更灵活地管理内存。

当你执行这个操作时，RP执行的内存是0，并且没有分配，所以你当然不能使用这个内存。

应该说RP指向的记忆是非法的。

尽管 rp=0 被视为初始化操作，但如果未为 RP 分配实际可用地址值，则 RP 不能用作指针，并且无法访问其地址。

p = tmp;这并不是说 P 复制了 TMP 数组，只是 P 中的值成为 TMP 的地址（P 指向 TMP）。 你可以把 p 看作是 tmp 的别名，就像一个人有两个名字，但无论如何，只有一个人。

初始化工作指针变量的唯一方法是为其分配一个有效的内存地址，即内存请求函数返回的内存地址或现有内存地址。 我们总是最终为这个指针变量分配一个有效的内存地址。

int *p,*k,v;

p=malloc(sizeof(int));

k=&v;k=p;

这些只是形式上的差异，无论如何，其中一个可用的指针必须指向合法地址。

声明数组为将存储在数组中的数据分配内存，而声明指针仅分配一段内存来保存它稍后指向的内存的地址。

数组本身被编译，系统为其分配内存。 指针只是一个指向内存片段的地址变量。

如果定义为 char rp[100]，编译器会在堆栈上为数组变量 rp 分配 100 字节的内存;

如果定义为 char*rp，则编译器为堆栈上的指针变量分配 sizeof（char*） 大小的内存，通常为 4 个字节; 要使 RP 有效，RP 指针必须指向有效的内存地址，在这种情况下，您可以在堆上为其分配额外的内存，或指向另一个字符串。

数组空间是静态分配的（即，在编译之前有空间），并且指针在不指向任何内存的情况下声明; 无法为其引用的内存分配值;

你可以这样做。

#include

#include

#include

void main()

elseprintf("p=[%s] len=[%d]", rp, len);

free(rp);释放 rp} 引用的内存空间我上面错了，如果指针在声明时没有初始化，它都指向同一个内存：

0xcccccccc（十六进制）。

而且这块内存在系统中是不可写的（就是不能分配），是的，其实有两种方式。

1. 动态分配内存。

2. 为指针变量赋值。

2 的二进制代码是 =10;

2+x = 10+10100111 = 10101001 = 转换为十进制 = 169;

3（3 的否定）= -4

169 4（按位异或运算）= -171

二进制表示。

85（十进制）。

如果 char x[2][10] = ; 字符 x[0][10] 等于什么？

答：没有等待，重复定义数组 x。

如果 char y[2][3][10] = ，} 那么 char y[2][3][10] 是什么？

答：没有，原理同上。

char y[2][2][10]=？

char y[1][1][10]=？

char y[1][2][10]=？

char y[0][0][10]=？

char y[0][0][0]=？

答：这五个是声明三维数组，但正确的表达是错误的，不是吗？ ，用 {} 或 “” 括起来。

字符 x[0][10 是 w;

char y[0][0][10]=w

char y[0][0][0]=h

仅在 y[1][1][2] 之前才有值。

数组包含字母。

v 是一个联合（commoner）变量，它有两个元素，x 和 c，它们都需要一个字节，并且它们被分配给同一个地址。 x 是一个结构变量，有三个元素，s1、s2 和 s3，分别占 2、3 和 3 位数字。 分配内存时，最低的位在前，最多的位在后。

当二进制文件为01100100）时，变量与内存存储之间的关系如图所示。

其中 x 的成员 s3 是二进制 011，即十进制 3，因此输出为 3。

这属于你的比特域问题！ X 和 c 在联合中共享一个内存空间，这就是为什么联合一次只能保存一种数据类型的值。

也就是说，结构变量 x 中三个字段的内存值为 100

100 01100100的二进制位。 （高字节->低字节）而一般的机器是小的endea，即低字节先，所以S3占用3位011输出为 3

既然我们可以通过申请 1 字节的内存来使用它背后的内存，为什么我们要在 malloc 中添加 size 参数呢？

1.请求1字节内存，可以使用p+1，但极有可能在运行时造成内存冲突。 操作系统管理内存，知道哪些可用，哪些不可用。 当我们使用 malloc 申请内存时，我们需要给 malloc 添加一个 length 参数，告诉操作系统这个内存已经用完了，其他程序不能用了。

从这个角度来看，char *p = （char *）malloc（sizeof（char））; 在那之后使用 p+1 是错误的。

例如，在同一楼层，如果 P 是 3200，那么 P+1 就是 3201P，指的是地址

回复 2 楼和 3 楼，即使只应用了一个 char 但 p+1 仍然有效，即使这里定义了 int 类型，p+1 仍然指向下一个，仍然可以调用，因为之前的定义是 char *p....

sizeof（char）中填写什么与返回的类型无关，填写char返回1，填写int返回2....然后用 malloc 打开空间，然后强制转换为 char* 类型。

由于 malloc 只申请了一个 char 空间，所以你只给 p 分配了空间，而 p+1 是无效的。

您可以在 sizeof 之前乘以 n（数字）以请求多个空格。

指向空格的下一个字节。

指向 p 指向的空间的下一个字节，因为 char 只占用一个字节！

一次复制一个字符。

for(int i = 0; i <3;i++)