数组与指针

在我们教学的时候，常常会碰到学生问：老师，数组和指针有没有区别，是不是数组就是指针，如果有区别，区别在哪里?为此我写了这篇文章，希望能有点启发给学生。

先从简单的说起，一维数组和指针。

平常我们操作数组都是通过数组名加下标的方式，那么这个数组名到底代表什么含义?其实数组名它是一个指针常量，它是一个地址，这个地址是数组的首地址，也就是数组第一个元素的地址。例如：

int a[10];

你可以去看一下，a, &a, &a[0]它都是同一个值，都是数组的首地址。

那么这个指针常量它的类型的是什么呢，如果数组元素的类型是int类型的，那么这个指针常量的类型就是int*，像这里就是int*类型。还有要注意的是这个指针是一个常量，不能修改这个值，但是有两种情况下数组名不被当作一个指针常量看待，一个是&运算，另一个是sizeof，一个常量肯定是没有地址的，所以&运算是取得数组的首地址，而sizeof是返回整个数组的长度，而不是返回的指针长度。

所以数组和指针是如此的相似，以至于它们可以互换使用。例如，数组元素除了使用下标方式操作外，还可以使用指针的方式：

*(a + 1)代表第二个元素， *(a + 2)代表第三个元素。

数组可以当作指针来使用，指针同样也可以当作数组来使用。

虽然数组和指针有如此相似地方，但是它们还是有区别的。

(1) 数组名这个指针它是一个指针常量，也就是你不能对它进行算数运算，例如a++这是错误的操作。但是我们定义的指针它却是一个变量。

(2) 我们定义一个数组，它就分配了相应大小的空间，但是定义指针，它只是分配4字节大小空间，它只能指向其它存储空间，否则，它没有任何意义。

既然数组和指针有如此多的相似之处，那我们到底是使用数组还是指针呢，这要看具体的上下环境，如果是数组，那么使用数组的下标形式更让人理解，让人一看就知道这是一个数组，如果是指针，那就直接使用指针的方式操作，这样也不会混淆程序的其它阅读者。

一维数组作为函数参数

当我们将一个数组作为参数传递给函数时，实际上是将数组的首地址传给了子函数。那么这个函数参数该怎么去定义呢，有两种写法，例如：

int strlen(char string[]);

int strlen(char* string);

这两种写法都是正确的，但是哪种写法更好呢，当然是使用指针的写法更好，因为我们的的确确是传递的一个指针给函数。

上面是简单的介绍，接下来是具体的解释：

数组是什么?什么是左值和右值?

笔者引用《C专家编程》中的一段话：

出现在赋值符左边的符号有时被称为左值，出现在赋值符右边的符号有时被称为右值。编译器为每个变量分配一个地址(左值)。这个地址在编译时可知，而且该变 量在运行时一直保存于这个地址。相反，存储于变量中的值(它的右值)只有在运行时才可知。如果需要用到变量中存储的值，编译器就发出指令从指定地址读入变 量值并将它存于寄存器中

我对左值的理解和书上有些区别，我把这里的“符号”称为“对象”，每一个符号都代表一个对象，对象与地址是一一对应的。即如果声明了 int a，那么 a 作为一个左值时，a 即代表这个保存在某个特定的地址的对象，对这个对象赋值即为把值放在这个特定的地址;a 作为右值时即代表 a 的内容，就是一个单纯的值，而不是对象。一个值是不能作为左值的，比如一个常数 1, 1 = a 这样的赋值语句是无法编译通过的。在我看来，“左值”义同“对象”，“右值”义同“值”，所以下面“左值”和“对象”指的是相同的东西。但是“左值”又有 一个子集：“可修改的左值”，只有这个子集中的东西才能放在赋值号左边，因此我认为将引用中的第一句话修改为“出现在赋值符左边的符号有时被称为可修改的 左值”更能表达其实际的意思。为什么要引出这个子集，为的就是要把数组分出来，数组是左值，但并不是可修改的左值，因此你也不能直接把数组名放在等号左边进行赋值。

数组就是数组!

我先把结论放在这里，然后在进行分析：数组就是数组，一个数组名就代表一个数组对象，这个对象内可以有一个或多个元素，每个元素类型都相同;正如 int 就是 int，一个 int 变量名就代表一个 int 类型对象。看到这里，你可能要笑了，这不是什么都没说吗，谁不知道数组是这个意思啊，我想知道数组和指针什么关系。其实对数组的认识就是这样一个返璞归真过程，看我来慢慢解释。

以下是代码：

1 /* 1.c */

2 int main()

3 {

4 int foo[] = {1};

5 int bar = 1;

6 return 0;

7 }

使用 gcc 将其汇编并以 intel 格式输出汇编语言文件：

1 gcc –S –masm=intel 1.c

关键部分：

1 mov DWORD PTR [esp+8], 1

2 mov DWORD PTR [esp+12], 1

esp+8 位置就是那个 int foo[]，esp+12 位置就是那个 int bar。可见，给 int 数组的赋值时就像给一个 int 变量赋值一样，并没用指针来进行间接访问，这个 int 数组对象 foo 的内存地址在编译时就确定了，是 esp+8;正如那个 int 对象 bar 一样，它的内存地址在编译时也确定了，是esp+12。

以示区别，我将下面代码同样以汇编语言输出：

1 /* 2.c */

2 #include

3 int main()

4 {

5 int *foo = (int *)malloc(sizeof (int));

6 *foo = 1;

7 return 0;

8 }

汇编的关键部分：

1 mov DWORD PTR [esp], 4

2 call _malloc

3 mov DWORD PTR [esp+28], eax

4 mov eax, DWORD PTR [esp+28]

5 mov DWORD PTR [eax], 1

前两句为 foo分配内存空间，第三句将分配的内存空间地址值赋给 foo，foo 的地址为 esp+28，编译时已知。下面是赋值部分，首先从 foo 那里得到地址值，然后向这个地址赋值，这里可以看出和给数组赋值的差别，给数组赋值时是将值直接赋到了数组中，而不用从哪里得到数组的地址。

由上面可以看出，数组更像一个普通的变量，编译时就知道了其地址，可以直接赋值。

数组作为左值

数组不能放在赋值号左边，但数组仍可以作为一个左值或者说对象出现在语句中，一个重要的例子就是取地址操作：&。取地址操作 &的操作数必须是一个左值，而不能是一个右值。比如一个变量int a = 1，&a 就可以得到 a 的地址，但 &1是非法的，一个单纯的数值是没有地址的。那么对于一个int foo[]，&foo 会返回一个什么样的值呢?自然是一个指向数组的指针咯，下面的程序可以看出来：

1 int main()

2 {

3 int foo[1];

4 int bar[1];

5 bar = &foo; //故意触发一个 error

6 return 0;

7 }

那个赋值语句一定会触发错误，我们可以根据编译输出来确定它们的类型，错误为：

1 error: incompatible types when assigning to type 'int[1]' from type 'int (*)[1]'

没错，&foo 返回数据类型为 int (*)[1]，就是一个指向数组的指针。指向数组?指向数组的哪里呢?指向数组对象首地址，正如一个指向 int 对象的指针指向那个 int 对象占有的两个或四个内存单元的首地址一样。

把 &foo 赋给一个普通的指针是可以的，不过会触发一个 warning，因为int * 与 int (*)[1] 并不相容。赋值后普通指针的值与 &foo 的值是相同的，都是数组对象的首地址，只是普通指针把这块内存当做 int 对象处理而已。

由于 C 语言是弱类型语言，你把 &foo 赋给int **********bar 或者 int *baz都是可以的，都不会导致 error，只会导致 warning，此时你打印出 *bar 或者 *baz 的值都是 foo 中第一个整数的值(前提是指针和数组占用空间大小相等)。正如文章开头的代码那样，以这个整数的值作为一个地址值进行间接访问(*(*bar))就会导致 非法访问的错误。

数组作为右值

数组作为右值时会发生什么?返回数组对象内的所有值自然不可能，因此 C 语言中采取的方法是数组作为右值时返回对象中元素类型的指针，指针指向第一个元素，类似上一个例子：

1 int main()

2 {

3 int foo[1];

4 int bar[1];

5 bar = foo; //故意触发一个 error

6 return 0;

7 }

出错信息为：

1 error: incompatible types when assigning to type 'int[1]' from type 'int *'

数组作为左值和数组作为右值时的区别造成了无数人的困惑与误解：foo 作为右值时确实等价于一个指针，因为数组无法像普通对象那样返回它的值，它的元素可能有成百上千个，但作为一个右值时——比如作为取地址操作符的操作数 时，数组就是作为一个数组对象而出现的，而不是指针，取地址返回一个指向数组的指针，而不是指向指针的指针。

接下来再分析下数组指针和指针数组的区别：

数组指针(也称行指针)

定义 int (*p)[n];

()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型数据的长度。

如要将二维数组赋给一指针，应这样赋值：

int a[3][4];

int (*p)[4]; //该语句是定义一个数组指针，指向含4个元素的一维数组。

p=a; //将该二维数组的首地址赋给p，也就是a[0]或&a[0][0]

p++; //该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][]

所以数组指针也称指向一维数组的指针，亦称行指针。

指针数组

定义 int *p[n];

[]优先级高，先与p结合成为一个数组，再由int*说明这是一个整型指针数组，它有n个指针 类型的数组元素。这里执行p+1是错误的，这样赋值也是错误的：p=a;因为p是个不可知的表示，只存在p[0]、p[1]、p[2]...p[n- 1],而且它们分别是指针变量可以用来存放变量地址。但可以这样 *p=a; 这里*p表示指针数组第一个元素的值，a的首地址的值。

如要将二维数组赋给一指针数组:

int *p[3];

int a[3][4];

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

p[i]=a[i];

这里int *p[3] 表示一个一维数组内存放着三个指针变量，分别是p[0]、p[1]、p[2]，所以要分别赋值。

这样两者的区别就豁然开朗了，数组指针只是一个指针变量，似乎是C语言里专门用来指向二维数组的，它占有内存中一个指针的存储空间。指针数组是多个指针变量，以数组形式存在内存当中，占有多个指针的存储空间。

还需要说明的一点就是，同时用来指向二维数组时，其引用和用数组名引用都是一样的。

比如要表示数组中i行j列一个元素：

*(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j]

综上所述一句话就是：数组就是数组，有着自己的特性。