C语言中数组对指针的赋值

片段1：

char** x;
char arr[][4] = {"abc","def"};
x = arr;                             // why is this wrong ? but;

片段2：

char* x;
char arr[4] = {"def"};
x = arr;                             // this is correct

那么，我们如何将2d数组分配给双指针（也适用于任何多维数组）

另外，我有一个结构，我想做如下赋值：

struct document
{
    char **text;
    int numOfLines;
};

char arr[3][50] = {
    "IF WE COULD TAKE THE TIME",
    "TO LAY IT ON THE LINE",
    "I COULD REST MY HEAD" };
t->text = arr;                           // I think it is the same problem

但是我们可以直接将双指针指定为：

t->text = { "IF WE COULD TAKE THE TIME", "TO LAY IT ON THE LINE", "I COULD REST MY HEAD" };

还有，为什么这样做有效：

char *arr[3] = {
    "IF WE COULD TAKE THE TIME",
    "TO LAY IT ON THE LINE",
    "I COULD REST MY HEAD" };
t->text = arr;

---

语句

char**x

表示指向指针的指针，但

字符arr[][4]是指向数组的指针。
下面的代码可以工作

#include <stdio.h>

int main(void)
{   
    char (*x)[10];
    char arr1[][10] = {{"First"}, {"Second"}};
    x = arr1;
    printf("%s\n%s\n", arr1[0], arr1[1]);
    printf("%s\n%s\n", x[0], x[1]);
    return 0;
}

#包括
内部主（空）
{   
字符（*x）[10]；
char arr1[][10]={{“第一”}、{“第二”}；
x=arr1；
printf（“%s\n%s\n”，arr1[0]，arr1[1]）；
printf（“%s\n%s\n”，x[0]，x[1]）；
返回0；
}
语句
char**x
表示指向指针的指针，但
字符arr[][4]是指向数组的指针。
下面的代码可以工作

#include <stdio.h>

int main(void)
{   
    char (*x)[10];
    char arr1[][10] = {{"First"}, {"Second"}};
    x = arr1;
    printf("%s\n%s\n", arr1[0], arr1[1]);
    printf("%s\n%s\n", x[0], x[1]);
    return 0;
}

#包括
内部主（空）
{   
字符（*x）[10]；
char arr1[][10]={{“第一”}、{“第二”}；
x=arr1；
printf（“%s\n%s\n”，arr1[0]，arr1[1]）；
printf（“%s\n%s\n”，x[0]，x[1]）；
返回0；
}
问题1
chararr[][4]={“abc”，“def”}
将
arr
定义为数组的数组。对于其他对象，例如结构，可以使用
B=C将一个结构（例如
C
）分配给相同类型的另一个结构（例如
B
）。但是，C对数组有特殊的规则

在表达式中使用数组时，它会自动转换为指向其第一个元素的指针，除非它是
sizeof
或一元
&
的操作数，或者是用于初始化数组的字符串文字。因此，当我们写作时：

x = arr;

自动转换使它看起来像我们写的：

x = &arr[0];

然后，由于
&arr[0]
是指向4个
char
数组的指针，
x
也必须是指向4个
char
数组的指针（或者是兼容的，可能是指向未知数量
char
数组的指针）

注意
char**x声明指向指针的指针。也就是说，它是一个指针，在它指向的内存中，必须有另一个指针。相反，
&arr[0]
是指向数组的指针。它是一个指针，在它指向的内存中，有一个由4个字符组成的数组。如果您尝试使用
**x
，编译器将查看
x
指向的内存，并期望在那里找到指针。相反，如果没有指针，而是四个任意的
char
值，程序将被破坏。因此
char**x
与指向4个
char
数组的指针不兼容

x
的正确声明应该是
char（*x）[4]。在这样的声明之后，赋值
x=arr将是合适的

问题2
你的代码
t->text={“如果我们能花点时间”，“把它放在线上”，“我可以休息一下”}
不是严格符合C的，并且不在典型的编译器中编译

问题3
考虑代码（调整以允许编译）：

char*arr[3]
将
arr
声明为指向
char
的三个指针的数组。然后将其初始化为包含指向字符串（第一个字符）的三个指针

因此，
arr
，
arr[i]
的每个元素都是指向
char
的指针。根据C关于数组自动转换的规则，在
t.text=arr，
arr
转换为指向其第一个元素的指针。所以我们有
t.text=&arr[0]。然后
&arr[0]
是指向
char
的指针，
t.text
是指向
char
的指针，因此类型是兼容的。
问题1
chararr[][4]={“abc”，“def”}
将
arr
定义为数组的数组。对于其他对象，例如结构，可以使用
B=C将一个结构（例如
C
）分配给相同类型的另一个结构（例如
B
）。但是，C对数组有特殊的规则

在表达式中使用数组时，它会自动转换为指向其第一个元素的指针，除非它是
sizeof
或一元
&
的操作数，或者是用于初始化数组的字符串文字。因此，当我们写作时：

x = arr;

自动转换使它看起来像我们写的：

x = &arr[0];

然后，由于
&arr[0]
是指向4个
char
数组的指针，
x
也必须是指向4个
char
数组的指针（或者是兼容的，可能是指向未知数量
char
数组的指针）

注意
char**x声明指向指针的指针。也就是说，它是一个指针，在它指向的内存中，必须有另一个指针。相反，
&arr[0]
是指向数组的指针。它是一个指针，在它指向的内存中，有一个由4个字符组成的数组。如果您尝试使用
**x
，编译器将查看
x
指向的内存，并期望在那里找到指针。相反，如果没有指针，而是四个任意的
char
值，程序将被破坏。因此
char**x
与指向4个
char
数组的指针不兼容

x
的正确声明应该是
char（*x）[4]。在这样的声明之后，赋值
x=arr将是合适的

问题2
你的代码
t->text={“如果我们能花点时间”，“把它放在线上”，“我可以休息一下”}
不是严格符合C的，并且不在典型的编译器中编译

问题3
考虑代码（调整以允许编译）：

char*arr[3]
将
arr
声明为指向
char
的三个指针的数组。然后将其初始化为包含指向字符串（第一个字符）的三个指针

所以