指针和多维数组

Question

可能重复： 如何在C++中使用数组？ 2d数组是双指针吗？ 二维数组和指针

我知道这是一个非常基本的问题，但没有多少谷歌为我澄清这一点。所以我才把它贴在这里。在c++中，考虑声明int x[10];

这是一个一维数组，x是基本指针，即它包含数组的第一个元素的地址。x给出了地址，*x给出了第一个元素。

同样适用于声明

 int x[10][20];

这里的x是什么样的变量。当我这么做

 int **z = x;

编译器说它不能将int (*)[20]转换成int **.And，为什么cout<<x;和cout<<*x;提供相同的值？同时，如果我声明一个指针数组为

 int *p[10];

那么x和p (它们的类型)之间有什么区别吗？因为当声明int x[10]和int *p时，将x分配给p是有效的，但是在二维数组的情况下则不是这样？为什么？有人能帮我澄清一下吗，或者提供一个很好的参考资料。

Answer 1

数组和指针不是一回事。在C和C++中，多维数组只是“数组”，不涉及指针。

int x[10][20];

是一个由10个数组组成的数组，每个数组包含20个元素。如果在上下文中使用x，它将衰减为指向其第一个元素的指针，那么您将得到一个指向这20个元素数组之一的指针--这就是您的int (*)[20]。请注意，这样的事情不是指针到指针，所以转换是不可能的。

int *p[10];

是一个由10个指针组成的数组，所以是的，它不同于x。

特别是，您可能遇到了困难，因为您似乎认为数组和指针是相同的--您的问题是：

这是一个一维数组，x是基本指针，即它包含数组的第一个元素的地址。X给我那个地址，*x给出第一个元素。

这不是真的。一维x是一个数组，只是在某些上下文中，数组会衰减为指向其第一个元素的指针。

阅读常见问题，了解你想知道的关于这个主题的一切。

Answer 2

多维数组只是语法糖。在幕后，这只是一个一维数组10 * 20 ints。当您在x[5][6]上访问一个元素时，编译器会生成与x[5 * 20 + 6]等价的元素；

Answer 3

下面是它的实际工作方式，请参阅代码和注释：

#include <stdio.h>

int x[3][5] =
{
  {  1,  2,  3,  4,  5 },
  {  6,  7,  8,  9, 10 },
  { 11, 12, 13, 14, 15 }
};

int (*pArr35)[3][5] = &x;
// &x is a pointer to an array of 3 arrays of 5 ints.

int (*pArr5a)[5] = x;
// x decays from an array of arrays of 5 ints to
// a pointer to an array of 5 ints,
// x is a pointer to an array of 5 ints.

int (*pArr5b)[5] = &x[0];
// &x[0] is a pointer to 0th element of x,
// x[0] is an array of 5 ints,
// &x[0] is a pointer to an array of 5 ints.

int *pInta = x[0];
// x[0] is 0th element of x,
// x[0] is an array of 5 ints,
// x[0] decays from an array of 5 ints to
// a pointer to an int.

int *pIntb = *x;
// x decays from an array of arrays of 5 ints to
// a pointer to an array of 5 ints,
// x is a pointer to an array of 5 ints,
// *x is an array of 5 ints,
// *x decays from an array of 5 ints to
// a pointer to an int.

int *pIntc = &x[0][0];
// x[0][0] is 0th element of x[0],
// where x[0] is an array of 5 ints,
// x[0][0] is an int,
// &x[0][0] is a pointer to an int.

int main(void)
{
  printf("&x=%p x=%p &x[0]=%p x[0]=%p *x=%p &x[0][0]=%p\n",
         pArr35, pArr5a, pArr5b, pInta, pIntb, pIntc);
  return 0;
}

样本输出：

&x=0040805c x=0040805c &x=0040805c x=0040805c *x=0040805c &x=0040805c

所有结果指针的值都是相同的，因为我显式或隐式地使用了0的索引，而且数组是连续的，而且它们的第一个(IOW，第0)元素总是位于数组中的最低地址。因此，即使有3种不同的指针类型，都有效地指向x，指向等于1的元素。

数组到指针的衰减是C和C++的一个非常重要的特性，尽管很难立即掌握。

它允许我们在将指针传递给数组时编写更紧凑的代码，我们可以只编写数组的名称，而不是获取其第一个元素的地址：

char str1[] = { 's', 't', 'r', '1', '\0' };
char str2[] = "str2";
printf("%s %s %s %s\n", &str1[0], str1, &str2[0], str2);

输出：

str1 str1 str2 str2

它也让我们做疯狂的事情：

int y[3] = { 10, 20, 30 };
printf("%d %d %d %d\n", y[2], *(y+2), *(2+y), 2[y]);

输出：

30 30 30

这都是因为当涉及到数组和指针时，a[b]等同于*(a+b)。