Chinaunix

标题: 大家来看看这个程序，解释出原因了就明白指针和数组的区别了（程序很短） [打印本页]
作者: zx_wing    时间: 2006-12-17 14:20
标题: 大家来看看这个程序，解释出原因了就明白指针和数组的区别了（程序很短）
这是我以前写的一个小程序，用来解释指针和数组的。理解了程序为什么会这样输出，就知道指针的数组的区别了。抛砖引玉，高手莫笑
文件一:t_arr_pointer1.c

  2. #include <stdio.h>

  4. char arr[] = "hello,world!";
  5. void print_arr(void)
  6. {
  7.     printf("arr addr:%p\n",arr);
  8. }
复制代码


文件二:t_arr_pointer2.c

  2. #include <stdio.h>

  4. extern char *arr;
  5. extern void print_arr(void);

  7. int main()
  8. {
  9.     print_arr();
  10.     printf("illusive pointer addr:%p\n",arr);
  11.     //printf("element 1 of arr:%p\n",arr[1]); //会引起段错误
  12. }
复制代码


在t_arr_pointer1.c 中，我定义了一个全局数组，但在t_arr_pointer2.c中，我声明了一个char *指针来引用这个数组。运行程序，为什么打印出来的地址不一样呢？要怎样才能得到正确的数组地址呢？

解释了这些问题，就明白了指针和数组的区别了。
作者: jronald    时间: 2006-12-17 14:50
extern引用好像只管根据名字传值，arr对外部来说就是整个数组的值，是这样吗？不太一致啊

  2. #include <stdio.h>

  4. char arr[] = "hello,world!";
  5. int ii=0xabc;

  7. void print_arr(void)
  8. {
  9.         printf("arr addr:%p\n",arr);
  10.         printf("sub ii:%x\n",ii);
  11. }

复制代码


  2. #include <stdio.h>

  4. extern char *arr;
  5. extern int *ii;
  6. extern void print_arr(void);

  8. int main()
  9. {
  10.     print_arr();
  11.     printf("illusive pointer addr:%p\n",arr);
  12.     printf("main ii: %x\n",ii);
  13. }
复制代码

[ 本帖最后由 jronald 于 2006-12-17 14:52 编辑 ]
作者: zx_wing    时间: 2006-12-17 15:01
原帖由 jronald 于 2006-12-17 14:50 发表
extern引用好像只管根据名字传值，arr对外部来说就是整个数组的值，是这样吗？不太一致啊
[code]
#include <stdio.h>

char arr[] = "hello,world!";
int ii=0xabc;

void print_arr(void ...


extern 在这里把本文件里的arr解释成了一个char *指针，所以全局的arr也被做为了一个char *指针
作者: converse    时间: 2006-12-17 15:02
C专家编程里面就有了。
作者: cugb_cat    时间: 2006-12-17 15:10
原帖由 converse 于 2006-12-17 15:02 发表
C专家编程里面就有了。

一定要把C专家编程看一遍～～～
作者: zx_wing    时间: 2006-12-17 15:11
原帖由 converse 于 2006-12-17 15:02 发表
C专家编程里面就有了。


是的，我最初就是在看了《c专家编程》后写的这个程序。
呵呵，我也是看到刚才的帖子，突然想起了，把这个程序翻出来了。
作者: zx_wing    时间: 2006-12-17 15:14
原帖由 cugb_cat 于 2006-12-17 15:10 发表

一定要把C专家编程看一遍～～～


一定要看，这本书是我学习的转折点啊，看了这本书，才能明白很多c贴近于机器级的表达。
以后再深入学习，就习惯从机器级看程序了哈。
作者: jronald    时间: 2006-12-17 15:28
为什么不把地址传给extern char *arr？
作者: zx_wing    时间: 2006-12-17 15:32
原帖由 jronald 于 2006-12-17 15:28 发表
为什么不把地址传给extern char *arr？


什么意思？extern char * arr 只是个声明
作者: jronald    时间: 2006-12-17 15:39
原帖由 zx_wing 于 2006-12-17 15:32 发表
什么意思？extern char * arr 只是个声明

那为什么用extern char *arr引用的arr不是数组起始地址，完全可以实现，这样可以与原来的arr保持一致，不是更好？

[ 本帖最后由 jronald 于 2006-12-17 15:40 编辑 ]
作者: zx_wing    时间: 2006-12-17 15:46
原帖由 jronald 于 2006-12-17 15:39 发表

那为什么用extern char *arr引用的arr不是数组起始地址，完全可以实现，这样可以与原来的arr保持一致，不是更好？


这个程序的目的，就是解释当一个数组名被解释成了指针后，会产生什么样的错误。由此可以看出数组名和指针的区别

>>那为什么用extern char *arr引用的arr不是数组起始地址

这个就是需要解释的东西哈
作者: Edengundam    时间: 2006-12-17 16:11
arr 编译后对应的地址是'h'所在的地址.
用arr看成指针之后, %p 打印 arr 内容. arr 取得数组中的前4个char作为值被返回了.
&arr 就看到数组的首地址了

我比较菜..说不太清楚

这个感觉和 c99 支持的可变**数组类似吧.

[ 本帖最后由 Edengundam 于 2006-12-17 16:13 编辑 ]
作者: zx_wing    时间: 2006-12-17 16:35
原帖由 Edengundam 于 2006-12-17 16:11 发表
arr 编译后对应的地址是'h'所在的地址.
用arr看成指针之后, %p 打印 arr 内容. arr 取得数组中的前4个char作为值被返回了.
&arr 就看到数组的首地址了

我比较菜..说不太清楚

这个感觉和 c99 支持的可 ...


说的已经很清楚了哈，这个就是区别。指针需要访存，取出存放在指针变量中的内容，解释成地址再使用。而数组本身就是地址，直接就可以使用。所以当一个数组名被解释成指针时，数组前4个字节(32位平台）的内容"hell"被解释成了地址。所以t_arr_pointer2.c打出来的是"hell"16进制的ascii码表示，如果是小端机器，表示为0x6c6c6568,大端机器表示为0x68656c6c。
作者: whyglinux    时间: 2006-12-17 17:28
>> 指针需要访存，取出存放在指针变量中的内容，解释成地址再使用。

这只适用于指针变量。对于指针常量（如 null 指针常量）以及由表达式计算得到的指针值不需要访问内存。

>> 而数组本身就是地址，直接就可以使用。

“数组是地址”和“数组是指针”这两种说法是等同的。如果数组是地址的话，你怎么解释对一个数组对象的取址操作？解释为取地址的地址吗？

再强调一遍，数组对象解释为数组类型还是指针类型（即地址）是由其在表达式中所处的上下文环境决定的，即取决于是左值语义还是右值语义。没有任何前提条件的时候，你不能确定“数组是作为数组类型使用”还是“数组是作为指针类型使用”。
作者: zx_wing    时间: 2006-12-17 17:54
原帖由 whyglinux 于 2006-12-17 17:28 发表
>> 指针需要访存，取出存放在指针变量中的内容，解释成地址再使用。

这只适用于指针变量。对于指针常量（如 null 指针常量）以及由表达式计算得到的指针值不需要访问内存。

>> 而数组本身就是地 ...


我已经在另一篇帖子中指出我们对指针定义的分歧了。这里我就不争论了。

>>这只适用于指针变量。对于指针常量（如 null 指针常量）以及由表达式计算得到的指针值不需要访问内存。
好，常量不说了。但表达式计算是需要访存的。
例如:

  2. char *ptr1;
  3. char *ptr2;
  4. char a[3] = {'1',;2',;3'};
  5. ptr = a;
  6. ptr2 = ptr1 + 1;
复制代码


在执行ptr2=ptr1+1这个计算时，第一条指令就是取ptr1的值，再加1存入ptr2中去。如果版主有不需要访存的指针表达式计算，请给出c代码和反汇编。

>>“数组是地址”和“数组是指针”这两种说法是等同的。如果数组是地址的话，你怎么解释对一个数组对象的取址操作？解释为取地址的地址吗？

对数组名的&操作只是返回数组首元素的地址，你不能因为可以是用这个操作就说数组名不是地址。并且&操作不是只能用于变量取地址。例如：

  2. char *str = &"hello,world";
  3. printf("%p\n", "hello,world");
  4. printf("%p\n", str);
复制代码


>>再强调一遍，数组对象解释为数组类型还是指针类型（即地址）是由其在表达式中所处的上下文环境决定的，即取决于是左值语义还是右值语义。没有任何前提条件的时候，你不能确定“数组是作为数组类型使用”还是“数组是作为指针类型使用”。

数组就是数组，指针就是指针，只是有时候两者行为相似。版主你可以给个例子，不告诉我任何前提条件，只告诉我这是个数组还是指针，然后给出操作，如果我不能确定操作如何进行，我就赞同你上面的观点。
作者: whyglinux    时间: 2006-12-17 18:18
>> 如果版主有不需要访存的指针表达式计算，请给出c代码和反汇编。

下面的表达式的计算都不需要进行内存访问：
  1. (int*)0 + 10
  2. &x + 10  // x 是一个静态对象。
复制代码


>> 版主你可以给个例子，不告诉我任何前提条件，只告诉我这是个数组还是指针，然后给出操作，如果我不能确定操作如何进行，我就赞同你上面的观点。

这我做不到。因为我如果给出操作了，也就等于告诉你使用环境了（因为运算符决定了操作数是左值还是右值语义）。我在上面所说的“没有任何前提条件”指的就是“在尚未确定进行何种操作的情况”。
作者: jronald    时间: 2006-12-18 00:12
原帖由 zx_wing 于 2006-12-17 15:46 发表


这个程序的目的，就是解释当一个数组名被解释成了指针后，会产生什么样的错误。由此可以看出数组名和指针的区别

>>那为什么用extern char *arr引用的arr不是数组起始地址

...


如果同一文件中，数组赋给指针没问题的

  2. #include <stdio.h>

  4. int main()
  5. {
  6.         char arr[]="hello";
  7.         printf("%p\n",arr);
  8.         char *p=arr;
  9.         printf("%p\n",p);
  10.         return 0;
  11. }
复制代码
作者: r2007    时间: 2006-12-18 09:05
此讨论结果必然是收敛的，最终会发现辨来辩去其实就是指针。不信走着瞧。
作者: zx_wing    时间: 2006-12-18 09:06
原帖由 whyglinux 于 2006-12-17 18:18 发表
>> 如果版主有不需要访存的指针表达式计算，请给出c代码和反汇编。

下面的表达式的计算都不需要进行内存访问：
  1. (int*)0 + 10
  2. &x + 10  // x 是一个静态对象。
复制代码


>> 版主你可 ...


这两个例子是不需要访存，但这不能说明指针和数组的区别，单独的讨论运算是否访存是没有意义的。例如

  2. int a = 1;
  3. a++;
复制代码

我可以肯定的说上述代码不需要访存，因为我没有给出上下文环境以及平台，所以总能找出一种不需要访存的情况。

但这些都是无助于说明指针和数组的区别。我强调指针访存只是想说明在数组和指针相似的行为下（例如用下标访问元素），其实质是不一样的。
作者: whyglinux    时间: 2006-12-18 09:41
>> int a = 1; a++;
>> 我可以肯定的说上述代码不需要访存，因为我没有给出上下文环境以及平台，所以总能找出一种不需要访存的情况。

何出此言？为了进行 a++ 的计算，总是首先要从内存中取得 a 的值。为了在变量 a 中存储计算结果，最终总是要将结果值写到 a 所在的内存中去，不论在什么平台上。

>> 我强调指针访存只是想说明在数组和指针相似的行为下（例如用下标访问元素），其实质是不一样的。

其实质是一样的：无论是用数组名、指针变量还是指针表达式访问数组元素，都是通过指针进行访问。所不同的只是指针值的来源有所差别罢了－－有的来自于一个数组对象，有的来自于一个指针变量，有的来自于一个表达式的值。
作者: r2007    时间: 2006-12-18 09:55
这里的a++其实就没有任何动作
  1. int a = 1;
  2.   sizeof(a++);
复制代码

BTW:主要想说sizeof是编译时的事，不要被它迷惑了。
作者: boxpei    时间: 2006-12-18 11:32
大家看看这个帖子，好像没那么复杂。

http://blogger.org.cn/blog/more.asp?name=newqiang&id=11178
作者: zx_wing    时间: 2006-12-18 12:58
原帖由 whyglinux 于 2006-12-18 09:41 发表
>> int a = 1; a++;
>> 我可以肯定的说上述代码不需要访存，因为我没有给出上下文环境以及平台，所以总能找出一种不需要访存的情况。

何出此言？为了进行 a++ 的计算，总是首先要从内存中取得 a  ...


首先我希望明确一个容易误解的概念:通常认为局部变量是放在栈上的，但实际不是这样。当局部变量的个数少于程序寄存器的个数时，变量会放在寄存器堆上，而不是栈上。所以，我如果把上面的代码这样写：

  2. void test()
  3. {
  4.      int a = 1;
  5.      a++;
  6. }
复制代码

有兴趣的朋友可以自己看看反汇编，会发现没有访存操作，a是放在一个寄存器里的（在x86平台上，我推测是eax)。

是我说的第一点，我没给出上下文。

其次，即使我程序这样写：

  2. void test()
  3. {
  4.       int a1 = 1;
  5.       int a2 = 2;
  6.       int a3 = 3;
  7.       int a4 = 4;
  8.       int a5 = 5;
  9.       int a6 = 6;
  10.       int a7 = 7;
  11.       int a8 = 8;
  12. }
复制代码

上面的变量是放在栈上吗？熟悉x86的朋友肯定会说，有部分放在栈上，因为寄存器溢出了。寄存器溢出是指变量个数超过程序寄存器个数的情况，这个时候部分变量会放到栈上去。像x86架构下，程序寄存器有8个，除去用做框架指针和栈指针的ebp和esp外，有6个可用。上述程序有8个变量，就会有两个放到栈上。但是我还是可以说它们不在栈上，前提条件是例如程序运行在IA64平台上。IA64平台共128个通用寄存器，除去32个系统可能会做特殊用途的外，还有96个可用。所以上面的程序也不会造成寄存器溢出，所有变量在寄存器堆上。这个就是我所说的第二点，我没有指定平台。

有个c中存在但很少被用的关键字：register，就是告诉编译器这个变量经常用到，把它放到寄存器中以提高效率。

所以说，光从语言的角度很多东西是讲不清楚的，例如数组和指针。再经典的教材只要是讲语言的，都不会把本质的东西讲的很清楚，这就造成了很多东西看上去一样，但实际是不一样的。

纠正上面的错误：和编译器行为有关，没有优化的时候可能是会访存的。优化级别高了上述代码会完全被优化掉。这是我例子举的不好，这里主要是想说明局部变量不一定在栈上。为了不造成误导，特指出上面的错误。

[ 本帖最后由 zx_wing 于 2006-12-18 14:02 编辑 ]
作者: r2007    时间: 2006-12-18 13:14
下面这个是立即数
  1. (int*)0 + 10
  2. &x + 10  // x 是一个静态对象。
复制代码

如果没有猜错的话，上面的如果作为右值的话，编译器会运算出结果，而目标代码中只有这个结果。

  1.      int a = 1;
  2.      a++;
  3. }
复制代码

这个和立即数不是一个概念。
编译器不会做预先计算，而是生成增一指令或add指令，由处理器在运行时运算。
作者: whyglinux    时间: 2006-12-18 13:16
To zx_wing

>> 有兴趣的朋友可以自己看看反汇编，会发现没有访存操作，a是放在一个寄存器里的（在x86平台上，我推测是eax)。

真的没有访存操作操作吗？那寄存器中的初始值是从哪里来的？
作者: mik    时间: 2006-12-18 13:21
有兴趣的朋友可以自己看看反汇编，会发现没有访存操作，a是放在一个寄存器里的（在x86平台上，我推测是eax)。


zx_wing这位朋友还是推测出来的，即使是放在 eax 也不能说明什么问题，gcc 根据情况而定

想要深入了解清楚，看gcc实现代码
作者: zx_wing    时间: 2006-12-18 13:22
原帖由 r2007 于 2006-12-18 13:14 发表
下面这个是立即数
  1. (int*)0 + 10
  2. &x + 10  // x 是一个静态对象。
复制代码

如果没有猜错的话，上面的如果作为右值的话，编译器会运算出结果，而目标代码中只有这个结果。

[code]     int a = 1;
  ...


是的，上面其实都是常量操作，静态变量x的地址在编译时就确定了，所以是立即数操作。

它们本身就不是一个东西，我只是想说明单纯的讨论是否访存没有意义。所以不要脱离指针和数组的范围来讨论这个问题。
作者: nully    时间: 2006-12-18 13:22
x86上，c语言从来不把寄存器变量放到eax, ebx, ecx, edx
它们只存在于edi,esi,所以编写程序从来不要指望寄存器变量会多于两个，而且，让编译器自动优化比人工控制好得多。
作者: zx_wing    时间: 2006-12-18 13:23
原帖由 whyglinux 于 2006-12-18 13:16 发表
To zx_wing

>> 有兴趣的朋友可以自己看看反汇编，会发现没有访存操作，a是放在一个寄存器里的（在x86平台上，我推测是eax)。

真的没有访存操作操作吗？那寄存器中的初始值是从哪里来的？


编译过后，初始化操作会被转换成一个立即数操作，例如：
mov $1, %eax

[ 本帖最后由 zx_wing 于 2006-12-18 13:58 编辑 ]
作者: zx_wing    时间: 2006-12-18 13:25
原帖由 mik 于 2006-12-18 13:21 发表


zx_wing这位朋友还是推测出来的，即使是放在 eax 也不能说明什么问题，gcc 根据情况而定

想要深入了解清楚，看gcc实现代码


是的，不具备任何意义。
嘿嘿，我之所以这样推测是因为我也是用gcc，很多程序习惯上编译出来后是这样用的
作者: mik    时间: 2006-12-18 13:30
贴出来看看不就行了吗
我推测优化时可以什么都不做,
作者: r2007    时间: 2006-12-18 13:32
原帖由 mik 于 2006-12-18 13:21 发表


zx_wing这位朋友还是推测出来的，即使是放在 eax 也不能说明什么问题，gcc 根据情况而定

想要深入了解清楚，看gcc实现代码

这句话在理，解释多了反而不如看编译器的代码（毕竟不是能理解的就能讲明白）
等读完了，愕然回首，灯火阑珊处，其实就是指针。:em11:
作者: whyglinux    时间: 2006-12-18 14:10
>> 编译过后，初始化操作会被转换成一个立即数操作，例如：
>> mov 1, %eax

这是加了优化之后的情况吧？

优化是一种等价实现，强调的是结果的对等性，其具体的实现过程没有可比性，一般不能用来说明原代码的情况。还是看没有优化下的汇编吧。
作者: zx_wing    时间: 2006-12-18 14:15
原帖由 whyglinux 于 2006-12-18 14:10 发表
>> 编译过后，初始化操作会被转换成一个立即数操作，例如：
>> mov 1, %eax

这是加了优化之后的情况吧？

优化是一种等价实现，强调的是结果的对等性，其具体的实现过程没有可比性，一般不能用 ...


我已经在前面注释强调不优化的情况可能访存，但也不是不优化都会访存。这里强调这种行为的存在，不强调这种行为一定会发生。上面代码也有误，1没加$。我不在x86上工作，对这个不太熟，这个地方纠正一下。
作者: VirusCamp    时间: 2006-12-18 16:28
原因在于 extern 从来不检查类型，你在第二个文件里写：

extern char arr;
extern char* arr;
extern long arr;

编译，连接，运行，都不会报错。
作者: whyglinux    时间: 2006-12-22 14:56
对同一对象的类型声明不一致是一种无定义行为。

>> 原因在于 extern 从来不检查类型

为了保证声明和定义的一致性，应该将声明单独放在一头文件中，在程序中进行声明此变量的时候要以包含头文件的方式进行（保证声明的一致性），在定义变量的文件中应该包含此头文件（这样可以在编译阶段检查出声明和定义是否一致）。
作者: Tim_tsang    时间: 2009-12-26 16:55
学习
作者: zx_wing    时间: 2009-12-26 17:22
哈哈哈，不得了不得了，这帖子都被挖坟出来了。
这还是当时我对C语言懵懂时发的，当时还有一系列和whyglinux争论的帖子。
后来事实证明了我那时候确实对很多概念搞不清楚，whyglinux对标准是真了解。
作者: unistd    时间: 2009-12-26 18:11
为什么地址不一样？
因为编译器做了手脚了！这个问题不是语言的范畴，而是编译器的实现细节！
按照模块来编译的模式，，第一个.c文件编译后，arr数组已经在模块内分配空间了，但是第二个.c文件中没有这个arr的位置信息，只有在连接的时候，才连接到第一个.o的文件里的字符数组的地址。。
作者: pmerofc    时间: 2009-12-26 19:45
提示: 作者被禁止或删除 内容自动屏蔽
作者: iLRainyday    时间: 2009-12-28 09:23
这个和指针和数组没什么太大关系，原因是在于link的时候对于类型的兼容性不作处理，标示符arr被解析到同一个地址，但是在不同的源文件中根据declearation的不同生成了不同的汇编代码，所以才出现了结果的不同。这个和不同源文件中的不同类型的同名强符号处理容易出现的错误是一样的道理。
作者: iLRainyday    时间: 2009-12-28 09:26
为什么地址不一样？
因为编译器做了手脚了！这个问题不是语言的范畴，而是编译器的实现细节！
按照模块来编译的模式，，第一个.c文件编译后，arr数组已经在模块内分配空间了，但是第二个.c文件中没有这个arr的位置信息，只有在连接的时候，才连接到第一个.o的文件里的字符数组的地址。。

正解~~



欢迎光临 Chinaunix (http://bbs.chinaunix.net/) Powered by Discuz! X3.2