数组名和指针的区别

这个问题也纠结我蛮久，看到这篇不错的博客就转过来啦。

转载请注明来源 http://blog.csdn.net/imred/article/details/45441457 

实际上关于数组与指针的区别这个问题在《C专家编程》已经有很详细的阐释，但我想用自己的语言说一说我的理解。

数组是指针？

最近在做数据结构课设，其中一个函数发生了令人费解的错误，简化后的代码如下：

#include <stdio.h>
int main()
{
    char foo[] = "abcde";
    char **bar = &foo;
    printf("%c\n", *(*bar));
    return 0;
}
 
 
1
2
3
4
5
6
7
8

程序执行到 printf 语句后便会挂掉，调试时会提示一个SIGSEGV信号，根据原来的经验，这时程序试图访问本不应该访问的内存。 
原来在 C 语言课堂上老师经常提到数组就是一个指针，指针也可以像数组那样用使用中括号的方式来进行内存访问。以这样的想法来分析前面的程序：foo 是一个字符指针，即 foo 的值即为“abcde”的首字符“a”的地址，*foo 即为 ‘a’；那么 foo 这个指针一定存在某个内存单元，&foo获得这个内存单元的地址，即 pfoo 是指向 foo 的指针，那么*pfoo 得到 foo，*(*pfoo)应该得到‘a’了；这样理解的话，程序是不应该有问题的。 
下面我们使用指针代替数组来实现上面的程序：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    char *foo = (char *)malloc(sizeof (char) * 2);
    *foo = 'a';
    *(foo + 1) = 0;
    char **pfoo = &foo;
    printf("%c\n", *(*pfoo));
    return 0;
}
 
 
1
2
3
4
5
6
7
8
9
10
11

程序这次运行结果和预料的相同，输出一个字母a。由此可见，数组就是指针，这种说法是错误的。

数组是静态常量指针（static/Compile-time constant）？

有人认为数组是一个静态常量，即数组名代表一个静态的地址值，在编译时确定，下面代码可以证伪这种说法

int main()
{
    char foo[] = {'a'};
    static char *p = foo;
    return 0;
}
 
 
1
2
3
4
5
6

使用 gcc 编译时会有以下错误：

error: initializer element is not constant
 
 
1

可见数组名并不是代表一个静态量，并非地址常量。如果定义 foo 时加上 static 限定符，编译就会通过，此时数组名才代表了一个静态量。

数组是动态常量指针（const/Runtime constant）？

请看以下代码：

int main()
{
    char foo[] = {'a'};
    char * const bar;    //为什么是这种写法，请自行查阅相关资料
    char *baz;           
    foo = baz;           /* 1 */
    bar = baz;           /* 2 */
    return 0;
}
 
 
1
2
3
4
5
6
7
8
9

gcc 编译时错误信息为：

/* 1 */ error: incompatible types when assigning to type 'char[1]' from type 'char *'
/* 2 */ error: assignment of read-only variable 'bar'
 
 
1
2

1 2 两处出错信息并不相同，若数组为动态常量指针，出错信息应像 2 那样。

数组是什么？

数组既不是静态常量，也不是指针，那么数组是什么？

左值和右值

首先补充一些左值和右值的知识，引用《C专家编程》中的一段话：

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

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

数组就是数组！

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

/* 1.c */
int main()
{
    int foo[] = {1};
    int bar = 1;
    return 0;
}
 
 
1
2
3
4
5
6
7

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

gcc -S -masm=intel 1.c
 
 
1

关键部分为：

mov     DWORD PTR [esp+8], 1
mov     DWORD PTR [esp+12], 1
 
 
1
2

esp+8 位置就是那个 int foo[]，esp+12 位置就是那个 int bar。可见，给 int 数组的赋值时就像给一个 int 变量赋值一样，并没用指针来进行间接访问，这个 int 数组对象 foo 的内存地址在编译时就确定了，是 esp+8；正如那个 int 对象 bar 一样，它的内存地址在编译时也确定了，是esp+12。 
以示区别，我将下面代码同样以汇编语言输出：

/* 2.c */
#include <stdlib.h>
int main()
{
    int *foo = (int *)malloc(sizeof (int));
    *foo = 1;
    return 0;
}
 
 
1
2
3
4
5
6
7
8

汇编的关键部分为：

mov     DWORD PTR [esp], 4
call    _malloc
mov     DWORD PTR [esp+28], eax
mov     eax, DWORD PTR [esp+28]
mov     DWORD PTR [eax], 1
 
 
1
2
3
4
5

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

数组作为左值

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

int main()
{
   int foo[1];
   int bar[1];
   bar = &foo;    //故意触发一个 error
   return 0;
}
 
 
1
2
3
4
5
6
7

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

error: incompatible types when assigning to type 'int[1]' from type 'int (*)[1]'
 
 
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 语言中采取的方法是数组作为右值时返回对象中元素类型的指针，指针指向第一个元素，类似上一个例子：

int main()
{
   int foo[1];
   int bar[1];
   bar = foo;    //故意触发一个 error
   return 0;
}
 
 
1
2
3
4
5
6
7

出错信息为：

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

foo 作为右值时返回了一个 int *，就是这个特性给人造成了数组就是指针的假象。

总结

数组作为左值和数组作为右值时的区别造成了无数人的困惑与误解：foo 作为右值时确实等价于一个指针，因为数组无法像普通对象那样返回它的值，它的元素可能有成百上千个，但作为一个左值时——比如作为取地址操作符的操作数时，数组就是作为一个数组对象而出现的，而不是指针，取地址返回一个指向数组的指针，而不是指向指针的指针。 
一句话总结就是：数组就是数组，有着自己的特性。 
（题外话：从生成的汇编语言看，用指针来访问内存实际上并不比使用数组来访问内存快，反而是慢了） 
转载请注明来源 http://blog.csdn.net/imred/article/details/45441457