char 和 int 中 **(ptr+1) 的值之差
Difference of value of **(ptr+1) in char and int
请帮我看看为什么下面的代码输出不同：
int z[][3] = { 1, 2, 3, 4, 5, 6 };
printf("\n**(z+1): %d", **(z + 1));
输出：(z+1): 4
char y[][3] = { "A", "F", "G", "J", "M", "P" };
printf("\n**(y+1): %c", **(y+1));
输出：(y+1): F
为什么在上面两个输出中，第一个是检查第 4 个索引，而第二个输出打印第二个索引？
如果你这样做
int z[][3] = { 1, 2, 3, 4, 5, 6 };
printf("\n**(z+1): %d", **(z + 1));
你真的得到了
int z[2][3] = { {1, 2, 3}, {4, 5, 6} };
printf("\n**(z+1): %d", **(z + 1));
根据这个定义，*(z+1) 指向 {4,5,6}，因此 **(z+1) 访问整数值 4。
您访问我们数组的第二个元素的第一个元素。
在您的第二个版本中会发生这种情况：
char y[][3] = { "A", "F", "G", "J", "M", "P" };
printf("\n**(y+1): %c", **(y+1));
这将导致
char y[6][3] = { {'A',0,0}, {'F',0,0}, {'G',0,0}, {'J',0,0}, {'M',0,0}, {P',0,0}};
printf("\n**(y+1): %c", **(y+1));
现在 *(y+1) 指向 {'F',0,0}，因此 **(y+1) 访问字符值 'F'。
您访问我们数组的第二个元素的第一个元素。
这实际上与第一个版本的结果相同。
Why in the above two outputs, first is checking the 4th index while in second output prints 2nd index ?
这实际上并不能描述正在发生的事情。
要理解发生了什么，请将示例写成它们的实际含义
int z[][3] = { 1, 2, 3, 4, 5, 6 };
printf("\n**(z+1): %d", **(z + 1));
实际上是
int z[][3] = { {1, 2, 3}, {4, 5, 6} };
printf("\n**(z+1): %d", **(z + 1));
其中 z[0] 是用 {1, 2, 3} 初始化的三个元素的数组，z[1] 是用 {4,5,6}.
初始化的三个元素的数组
在这个z + 1等于&z[0] + 1也就是等于&z[1]（三个int的数组的地址）。所以 *(z+1) 是（引用）z[1]（三个元素的数组），**(z+1) 是 z[1][0]。由于 z[1] 是一个初始化为元素 {4,5,6} 的数组，因此 z[1][0] 是该数组的第一个元素。这具有 4.
的值
相比之下，
char y[][3] = { "A", "F", "G", "J", "M", "P" };
printf("\n**(y+1): %c", **(y+1));
每个字符串文字都被初始化为两个元素的数组，例如"A" 初始化为 {'A', '[=32=]'}.
现在y是三个char数组的数组。如果一个包含三个元素的数组被赋予一个带有两个 char 的初始化器，就像这里的情况一样，未明确初始化的值将被零初始化。所以
char y[][3] = { "A", "F", "G", "J", "M", "P" };
等同于
char y[][3] = { {'A', '[=14=]', '[=14=]'}, {'F', '[=14=]', '[=14=]'}, {'G', '[=14=]', '[=14=]'}, {'J', '[=14=]', '[=14=]'}, {'M', '[=14=]', '[=14=]'}, {'P', '[=14=]', '[=14=]'}};
所以y是六个元素的数组，每个元素是三个char的数组。
使用与上面讨论 z 相同的逻辑，y + 1 等于 &y[1]，其中 y[1] 是三个 char 的数组初始化为 {'F', '[=43=]', '[=43=]'}。
所以 *(y + 1) 是（对）y[1] 的引用，而 **(y + 1) 是 y[1][0]。这具有 'F'.
的值
如果你在每个数组中只使用一个字符，你实际上不需要二维字符数组。
点赞：
char y[] = { 'A', 'F', 'G', 'J', 'M', 'P' };
printf("\n**(y+1): %c", *(y + 1));
请帮我看看为什么下面的代码输出不同：
int z[][3] = { 1, 2, 3, 4, 5, 6 };
printf("\n**(z+1): %d", **(z + 1));
输出：(z+1): 4
char y[][3] = { "A", "F", "G", "J", "M", "P" };
printf("\n**(y+1): %c", **(y+1));
输出：(y+1): F
为什么在上面两个输出中，第一个是检查第 4 个索引，而第二个输出打印第二个索引？
如果你这样做
int z[][3] = { 1, 2, 3, 4, 5, 6 };
printf("\n**(z+1): %d", **(z + 1));
你真的得到了
int z[2][3] = { {1, 2, 3}, {4, 5, 6} };
printf("\n**(z+1): %d", **(z + 1));
根据这个定义，*(z+1) 指向 {4,5,6}，因此 **(z+1) 访问整数值 4。
您访问我们数组的第二个元素的第一个元素。
在您的第二个版本中会发生这种情况：
char y[][3] = { "A", "F", "G", "J", "M", "P" };
printf("\n**(y+1): %c", **(y+1));
这将导致
char y[6][3] = { {'A',0,0}, {'F',0,0}, {'G',0,0}, {'J',0,0}, {'M',0,0}, {P',0,0}};
printf("\n**(y+1): %c", **(y+1));
现在 *(y+1) 指向 {'F',0,0}，因此 **(y+1) 访问字符值 'F'。
您访问我们数组的第二个元素的第一个元素。
这实际上与第一个版本的结果相同。
Why in the above two outputs, first is checking the 4th index while in second output prints 2nd index ?
这实际上并不能描述正在发生的事情。
要理解发生了什么，请将示例写成它们的实际含义
int z[][3] = { 1, 2, 3, 4, 5, 6 };
printf("\n**(z+1): %d", **(z + 1));
实际上是
int z[][3] = { {1, 2, 3}, {4, 5, 6} };
printf("\n**(z+1): %d", **(z + 1));
其中 z[0] 是用 {1, 2, 3} 初始化的三个元素的数组，z[1] 是用 {4,5,6}.
在这个z + 1等于&z[0] + 1也就是等于&z[1]（三个int的数组的地址）。所以 *(z+1) 是（引用）z[1]（三个元素的数组），**(z+1) 是 z[1][0]。由于 z[1] 是一个初始化为元素 {4,5,6} 的数组，因此 z[1][0] 是该数组的第一个元素。这具有 4.
相比之下，
char y[][3] = { "A", "F", "G", "J", "M", "P" };
printf("\n**(y+1): %c", **(y+1));
每个字符串文字都被初始化为两个元素的数组，例如"A" 初始化为 {'A', '[=32=]'}.
现在y是三个char数组的数组。如果一个包含三个元素的数组被赋予一个带有两个 char 的初始化器，就像这里的情况一样，未明确初始化的值将被零初始化。所以
char y[][3] = { "A", "F", "G", "J", "M", "P" };
等同于
char y[][3] = { {'A', '[=14=]', '[=14=]'}, {'F', '[=14=]', '[=14=]'}, {'G', '[=14=]', '[=14=]'}, {'J', '[=14=]', '[=14=]'}, {'M', '[=14=]', '[=14=]'}, {'P', '[=14=]', '[=14=]'}};
所以y是六个元素的数组，每个元素是三个char的数组。
使用与上面讨论 z 相同的逻辑，y + 1 等于 &y[1]，其中 y[1] 是三个 char 的数组初始化为 {'F', '[=43=]', '[=43=]'}。
所以 *(y + 1) 是（对）y[1] 的引用，而 **(y + 1) 是 y[1][0]。这具有 'F'.
如果你在每个数组中只使用一个字符，你实际上不需要二维字符数组。
点赞：
char y[] = { 'A', 'F', 'G', 'J', 'M', 'P' };
printf("\n**(y+1): %c", *(y + 1));