C语言:数组和指针的区别

版权声明:转载请注明来源: https://blog.csdn.net/imred/article/details/45441457

转载请注明来源 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;
}

程序执行到 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;
}

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

数组是静态常量指针(static/Compile-time constant)?

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

int main()
{
    char foo[] = {'a'};
    static char *p = foo;
    return 0;
}

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

error: initializer element is not constant

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

数组是动态常量指针(const/Runtime constant)?

请看以下代码:

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

gcc 编译时错误信息为:

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

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;
}

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

gcc -S -masm=intel 1.c

关键部分为:

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

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;
}

汇编的关键部分为:

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

前两句为 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;
}

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

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 语言中采取的方法是数组作为右值时返回对象中元素类型的指针,指针指向第一个元素,类似上一个例子:

int main()
{
   int foo[1];
   int bar[1];
   bar = foo;    //故意触发一个 error
   return 0;
}

出错信息为:

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

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

总结

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

没有更多推荐了,返回首页