数组名#

我们从简单的来看数组，首先看下面这两个声明：

1
int a;
2
int b[10];

我们把变量 a 称为标量，因为它是个单一的值，这个变量的类型是一个整数。

我们把变量 b 称为数组，因为它是一些值的集合。其中 b 为数组名，[] 内部为下标。使用数组和下标时有两种情况：

1. 当数组声明时，下标内的值为一个常量，表示这个数组的长度。
2. 当下标和数组名一起在声明外使用时（即形如 b[i] 时），用于标识该集合中某个特定的值。

例如，在例子中的声明中表示，创建了一个整数型的数组 b，它的长度为 10，即 0~9。

在声明之外 b[0] 表示数组 b 的第 1 个值，b[4] 表示第 5 个值。每个特定值都是一个标量，可以用于任何可以使用标量数据的上下文环境中。（数组的值从 0 开始）

那么 b[4] 的类型是整型，但 b 的类型又是什么？

在 C 中，在几乎所有使用数组名的表达式中，数组名的值是一个指针常量，也就是数组第 1 个元素的地址。

即：b = &b[0];

数组与指针相比，数组具有确定数量的元素，而指针只是一个标量值。编译器用数组名来记住这些属性。只有当数组名在表达式中使用时，编译器才会为它产生一个指针常量。

下标引用#

在对比数组的下标引用和指针的时候，我们先要给出一句话：

WARNING

C 的下标引用和间接访问表达式是一样的。

我们知道在数组中的下标引用有两种情况，我们更多用的是第二种，那么我们是否可以用间接访问来表示呢？

接着上面的例子，我们看 *( b + 3 )

首先，b 的值是一个指向整型的指针，所以 3 这个值根据整型值的长度进行调整。加法运算的结果是另一个指向整型的指针，它所指向的是数组第 1 个元素向后移 3 个整数长度的位置。然后，间接访问操作访问这个新位置，或者取得那里的值（右值），或者把一个新值存储于该处（左值）。

我们发现它和下标引用的执行过程完全相同。

那么总结一下，下面这两个表达式是等价的：

• array[subscript]
• *(array+(subscript))

证明：第一个表达式，在下标表达式中，子表达式 subscript 首先进行求值。然后，这个下标值在数组中选择一个特定的元素；在第 2 个表达式中，内层的那个括号保证子表达式 subscript 像前一个表达式那样首先进行求值。经过指针运算，加法运算的结果是一个指向所需元素的指针。然后，对这个指针执行间接访问操作，访问它指向的那个数组元素。

我们举个例子来理解这些，假如有：

1
int array[10];
2
int *ap = array + 2;

很明显，看这个声明，指针 ap 指向 array[2]。

我们来看看几个表达式它们表示的意思：

• ap：这个很简单，你只要阅读它的初始化表达式就能得到答案：array+2，它还可以写成：ap=&array[2];
• *ap：间接访问 ap 所指向的元素，即访问 array[2]，*ap 就是 array[2] 所代表的值。
• ap+6：ap 指向 array[2]，加法运算产生的指针所指向的元素是 array[2] 向后移动 6 个整数位置的元素，即 array+8 或 &array[8]。
• *ap+6：间接访问的运算优先级高于加号运算，间接访问的结果再与 6 相加，所以这个表达式相当于表达式 array[2]+6。
• *(ap+6)：括号迫使加法运算首先执行，所以我们这次得到的值是 array[8]。
• ap[0]：你也许会诧异，这是什么东西？ap 是一个指针变量，又不是一个数组，这怎么能成立呢？其实它是正确的，还是因为那句话：C 的下标引用和间接访问表达式是一样的。下标引用可以转化成间接访问，即 ap[0]=*(ap+(0))，其结果与前一个表达式相等。因此，它的答案就是 array[2]。
• ap[6]：同上，它可以转化为间接访问，即 ap[6]=*(ap+6)。
• &ap：这个表达式是完全合法的，我们求的是指针变量的地址，此时没有对等的涉及 array 的表达式。
• ap[-1]：负值的下标？下标引用就是间接访问表达式，你只要把它转换为那种形式并对它进行求值。所以同上，表示 array[1]。（注意：数组的下标引用时不能有负数！）

我们看这些例子，可以总结出下标引用和间接访问的替换方法：

1
a[b]=*(a+b);// a,b 必须是地址

除了这些常规的情况，我们还有一个非常规的情况：

2[array]：第一眼看，这肯定是非法的，但它是合法的。我们把它转换成对等的间接访问表达式，你就会发现它的有效性：*(2+array)，加法运算的两个操作数是可以交换位置的，所以这个表达式和 *(array+2) 完全一样。也就是说，最初那个看上去颇为古怪的表达式与 array[2] 是相等的。

对编译器来说，这两种形式并无差别。但是，这么写代码就是折磨自己和别人，最好别这样写。

数组和指针的区别#

看了上面的例子后，你可能会认为指针和数组其实是相等的，但指针和数组并不是相等的，看下面这个声明：

1
int a[5];
2
int *b;

a 是一个数组（名），b 是一个指针变量。a 和 b 都具有指针值，它们都可以进行间接访问和下标引用操作。但是，它们还是存在很大的区别。

• 声明一个数组时，编译器将根据声明所指定的元素数量为数组保留内存空间，然后再创建数组名，它的值是一个常量，指向这段空间的起始位置。
• 声明一个指针变量时，编译器只为指针本身保留内存空间，它并不为任何整型值分配内存空间。而且，指针变量并未被初始化为指向任何现有的内存空间，如果它是一个自动变量，它甚至根本不会被初始化。

因此，上述声明之后，表达式 *a 是完全合法的，但表达式 *b 却是非法的。*b 将访问内存中某个不确定的位置，或者导致程序终止。另一方面，表达式 b++ 可以通过编译，但 a++ 却不行，因为 a 的值是个常量。

初始化数组#

在声明数组的时候我们是否可以使用指针呢？当然可以，例如：

1
char message1[] = "Hello";
2
char *message2 = "Hello";

这两个初始化看上去很像，但它们具有不同的含义。前者初始化一个字符数组的元素，而后者则是一个真正的字符串常量。这个指针变量被初始化为指向这个字符串常量的存储位置。

存储顺序#

考虑下面这个数组：int array[3]; 它包含 3 个元素。

继续看下面这个新的声明：int array[3][6]; 我们可能第一时间把它想成是矩阵，但实际上计算机存储是线性的，所以在内存中是按行主序排列。

这个例子说明了数组元素的存储顺序（storage order）。在 C 中，多维数组的元素存储顺序按照最右边的下标率先变化的原则，称为行主序（row major order）。

我们平时可以把多维数组按矩阵或其他形式来想象，但实际上不是。

数组名#

多维数组第 1 维的元素实际上是另一个数组，多维数组可以看为是一个一维数组，包含 3 个元素，只是每个元素恰好是包含 10 个整型元素的数组。

例如：int matrix[3][10]; matrix 这个名字的值是一个指向它第 1 个元素的指针，所以 matrix 是一个指向一个包含 10 个整型元素的数组的指针。

同理，matrix[3] 也是一个地址，这个名字的值表示 10 个元素数组的首元素的地址，即：matrix[3] = &matrix[3][0];

即：当维度大于下标数时，此时是一个名字，代表下标数 + 1 的元素（数组）的首元素（数组）地址。

下标引用#

我们定义：int matrix[3][10]; 则此时 matrix 表示了指向包含 10 个整型元素的数组的指针，它指向包含 10 个整型元素的第 1 个子数组。

那么 matrix+1 又是什么呢？matrix 表示了指向包含 10 个整型元素的数组的指针，是把数组看成了一个个元素，则 matrix+1 就是向下移动一行，因为 1 这个值根据包含 10 个整型元素的数组的长度进行调整，所以它指向 matrix 的下一行。把它写成间接访问的形式：*(matrix + 1) 事实上标识了一个包含 10 个整型元素的子数组。

指向数组的指针#

我们假设有以下这些声明：

1
int vector[10], *vp = vector; // ok
2
int matrix[2][10], *mp = matrix; // error

• 第 1 个声明是合法的。它为一个整型数组分配内存，并把 vp 声明为一个指向整型的指针，并把它初始化为指向 vector 数组的第 1 个元素。vector 和 vp 具有相同的类型：指向整型的指针。
• 第 2 个声明是非法的。mp 的初始化不正确，因为 matrix 并不是一个指向整型的指针，而是一个指向整型数组的指针。

我们应该怎样声明一个指向整型数组的指针的呢？应该：int (*p)[10];

下标引用的优先级高于间接访问，但由于括号的存在，首先执行的还是间接访问。所以，p 是个指针。接下来执行的是下标引用，所以 p 指向某种类型的数组。

则和上面的声明联系在一起就是：int (*p)[10] = matrix; p 是一个指向拥有 10 个整型元素的数组的指针。当你把 p 与一个整数相加时，该整数值首先根据 10 个整型值的长度进行调整，然后再执行加法。所以我们可以使用这个指针一行一行地在 matrix 中移动。

如果你需要一个指针逐个访问整型元素而不是逐行在数组中移动，那根据之前数组名时的介绍，应该这样定义：int *pi = matrix[0]; 增加这个指针的值使它指向下一个整型元素。

初始化#

我们在输入数据到数组时，通常通过循环，例如：

1
int array[11];
2
for (int i = 1; i <= 10; i++)
3
    scanf("%d", &array[i]);

此时使用的是下标运算，那我们可不可以用指针呢？也可以，而且在输入内容多的时候指针反而更有效率。

1
int array[10], *ap;
2
for (ap = array + 1; ap <= array + 11; ap++)
3
    scanf("%d", ap);