C语言里面的指针和数组

kj501

Post by sybaselu
我来凑合两句：
int const *p               //p是常数指针，只能指向一个int数，所指的内容可以变，但p不能变；

说反了吧。

freegnu

指针只是一个普通变量，数组是一段连续分配的内存空间

herberteuler

这个问题其实很简单，只要看看编译器产生的代码，即使不作任何说明也能分清指针和数组的区别了。

1. #include <stdio.h>
   
2. 
   
3. int main(int argc, char *argv[])
   
4. {
   
5.         int a[] = {1, 2, 3};
   
6.         int *p = &a[1];
   
7. 
   
8.         a[1] = 4;
   
9.         *p = 4;
   
10.         printf("%d\n%d\n%d\n%p\n%p\n", a[0], *p, a[1], a, p);
    
11.         return 0;
    
12. }
    
13. 
    

复制代码

用 gcc 编译产生的汇编代码是这样的：

1.         # 一些给汇编器看的内容
   
2.         .file   "x.c"
   
3.         .section        .rodata
   
4. .LC0:
   
5.         .string "%d\n%d\n%d\n%p\n%p\n"
   
6.         .text
   
7. .globl main
   
8.         .type   main, @function
   
9. 
   
10. # main 函数
    
11. main:
    
12.         # main 函数的初始化
    
13.         pushl   %ebp
    
14.         movl    %esp, %ebp
    
15.         subl    $72, %esp
    
16.         andl    $-16, %esp
    
17.         movl    $0, %eax
    
18.         subl    %eax, %esp
    
19. 
    
20.         # 数组 a 的初始化。地址为：
    
21.         # a[0]    <->    -24(%ebp)
    
22.         # a[1]    <->    -20(%ebp)
    
23.         # a[2]    <->    -16(%ebp)
    
24.         # 注意数组元素的访问方式
    
25.         movl    $1, -24(%ebp)
    
26.         movl    $2, -20(%ebp)
    
27.         movl    $3, -16(%ebp)
    
28. 
    
29.         # 指针 p 的初始化：共三步
    
30.         # 取数组 a 的起始地址
    
31.         leal    -24(%ebp), %eax
    
32.         # 取 a[1] 的地址
    
33.         addl    $4, %eax
    
34.         # 为指针 p 赋值
    
35.         movl    %eax, -28(%ebp)
    
36. 
    
37.         # a[1] = 4
    
38.         movl    $4, -20(%ebp)
    
39. 
    
40.         # *p = 4：共两步
    
41.         # 取指针 p 的地址
    
42.         movl    -28(%ebp), %eax
    
43.         # 移入指针 p 指向的地址
    
44.         # 注意寻址方式
    
45.         movl    $4, (%eax)
    
46. 
    
47.         # 下面准备调用 printf
    
48.         # 参数：从左至右压入堆栈但写入的顺序相反
    
49.         # 首先压入指针 p 指向的地址
    
50.         movl    -28(%ebp), %eax
    
51.         movl    %eax, 20(%esp)
    
52.         # 再压入数组 a 的起始地址
    
53.         leal    -24(%ebp), %eax
    
54.         movl    %eax, 16(%esp)
    
55.         # 压入 a[1]：只一步
    
56.         movl    -20(%ebp), %eax
    
57.         movl    %eax, 12(%esp)
    
58.         # 压入 *p：分两步
    
59.         # 首先取出指针 p 指向的地址
    
60.         movl    -28(%ebp), %eax
    
61.         # 然后压入这个地址中的内容
    
62.         # 注意寻址方式
    
63.         movl    (%eax), %eax
    
64.         movl    %eax, 8(%esp)
    
65.         # 压入 a[0]：只一步
    
66.         movl    -24(%ebp), %eax
    
67.         movl    %eax, 4(%esp)
    
68.         # 参数全部压入堆栈，调用 printf
    
69.         movl    $.LC0, (%esp)
    
70.         call    printf
    
71. 
    
72.         # 准备从 main 返回，return 0
    
73.         movl    $0, %eax
    
74.         leave
    
75.         ret
    
76. 
    
77.         # 其他一些内容
    
78.         .size   main, .-main
    
79.         .section        .note.GNU-stack,"",@progbits
    
80.         .ident  "GCC: (GNU) 3.3.4 (Debian 1:3.3.4-13)"
    

复制代码

我加了些注释，同时也说明了 C 中的指针和数组是如何被使用的。可以看到的是，数组元素的大小在编译时确定，并被写入到汇编代码中。这样，就可以用诸如 -24(%ebp) 和 -20(%ebp) 这样的形式访问数组元素而不必担心数据被覆盖，并且可以使用像 addl  $4, %eax 这样的汇编指令。读了这些汇编指令，就能够彻底明白数组与指针的区别了吧。

jeffxia

herberteuler
强！
赞！

iamone

Post by kj501
来一段林锐的C/C++编程指南吧，说得比较清楚：
7.3.1 修改内容
        示例7-3-1中，字符数组a的容量是6个字符，其内容为hello\0。a的
内容可以改变，如a[0]= ‘X’。指针p指向常量字符串“world”（位于静态
存储区，内容为world\0），常量字符串的内容是不可以被修改的。从语法上
看，编译器并不觉得语句p[0]= ‘X’有什么不妥，但是该语句企图修改常量
字符串的内容而导致运行错误。

  char a[] = “hello”;
  a[0] = ‘X’;
  cout << a << endl;
  char *p = “world”;     // 注意p指向常量字符串
  p[0] = ‘X’;                   // 编译器不能发现该错误
  cout << p << endl;

如下代码在不同的平台上有不同的结果：

1. 
   
2. int
   
3. foo(void)
   
4. {
   
5.         char *p="world\n";
   
6.         p[0]='X';
   
7.         return 0;
   
8. }
   
9. 
   

复制代码

在AIX5，sun C++ 编译器上可以运行，结果是Xorld.
在linux上无法运行，发生段错误。
汇编代码如下：

1. 
   
2.         .file   "t.c"
   
3.         .section        .rodata
   
4. .LC0:
   
5.         .string "world\n"
   
6.         .text
   
7. .globl foo
   
8.         .type   foo, @function
   
9. foo:
   
10.         pushl   %ebp
    
11.         movl    %esp, %ebp
    
12.         subl    $4, %esp
    
13.         movl    $.LC0, -4(%ebp)
    
14.         movl    -4(%ebp), %eax
    
15.         movb    $88, (%eax)
    
16.         movl    $0, %eax
    
17.         leave
    
18.         ret
    
19.         .size   foo, .-foo
    
20.         .section        .note.GNU-stack,"",@progbits
    
21.         .ident  "GCC: (GNU) 3.4.1 (Mandrakelinux 10.1 3.4.1-4mdk)"
    

复制代码

我认为这是与操作系统有关的，对于 C来说（非C++).

kj501

这个问题确实和操作系统有关。大多数的操作系统是把静态数据设置成只读的。

kj501

Post by kj501
这个问题确实和操作系统有关。大多数的操作系统是把静态数据设置成只读的。

说得不对。应该是char *s="csaf";之类的字符串将被当作只读字符串处理。但有些操作系统对于只读数据保存的区域不一定能有效保护。可以会出现本来应该只读的字符串可以被改写的情况。

herberteuler

？
有几个 kj501 啊？

iamone

Post by kj501
这个问题确实和操作系统有关。大多数的操作系统是把静态数据设置成只读的。

没错。如下代码就可以正常运行。

1. #include        <string.h>
   
2. 
   
3. int
   
4. main(void)
   
5. {
   
6.         char *p,ch[20];
   
7.         strcpy(ch,"world\n");
   
8.         p=ch;
   
9.         p[0]='X';
   
10.         printf("p=%s",p);
    
11.         return 0;
    
12. }

复制代码

kj501

Post by herberteuler
？
有几个 kj501 啊？

我就是我呀。两个贴子都是我发的，刚开始时大脑不清楚，后来才发现自己说错了。但我的风格是不喜欢改贴子。所以就重新发贴进行纠正。