C语言之指针复习

在计算机中，所有的数据都是存放在内存中的，一般把内存中的一个字节称为一个内存单元，不同的数据类型所占用的内存单元数不一样，如int占用4个字节，char占用1个字节。为了正确地访问这些内存单元，必须为每个内存单元编上号。每个内存单元的编号是唯一的，根据编号可以准确地找到该内存单元。

内存单元的编号叫做地址（Address），也称为指针（Pointer）。 

内存单元的指针和内存单元的内容是两个不同的概念。 可以用一个通俗的例子来说明它们之间的关系。我们用银行卡到ATM机取款时，系统会根据我们的卡号去查找账户信息，包括存取款记录、余额等，信息正确、余额足够的情况下才允许我们取款。在这里，卡号就是账户信息的指针， 存取款记录、余额等就是账户信息的内容。对于一个内存单元来说，单元的地址（编号）即为指针，其中存放的数据才是该单元的内容。

在C语言中，允许用一个变量来存放指针，这种变量称为指针变量。因此，一个指针变量的值就是某个内存单元的地址或称为某内存单元的指针。

设有字符变量c，其内容为 'K'（ASCII码为十进制数 75），c占用了0X11A号内存单元（地址通常用十六进数表示）。设有指针变量p，内容为 0X11A，这种情况我们称为p指向变量c，或说p是指向变量c的指针。

 

严格地说，一个指针是一个地址，是一个常量。而一个指针变量却可以被赋予不同的指针值，是变量。但常把指针变量简称为指针。为了避免混淆，本教程约定：“指针”是指地址，是常量，“指针变量”是指取值为地址的变量。定义指针的目的是为了通过指针去访问内存单元。

既然指针变量的值是一个地址，那么这个地址不仅可以是变量的地址，也可以是其它数据结构的地址。在一个指针变量中存放一个数组或一个函数的首地址有何意义呢？

因为数组或函数都是连续存放的。通过访问指针变量取得了数组或函数的首地址，也就找到了该数组或函数。这样一来，凡是出现数组，函数的地方都可以用一个指针变量来表示，只要该指针变量中赋予数组或函数的首地址即可。这样做，将会使程序的概念十分清楚，程序本身也精练、高效。

在C语言中，一种数据类型或数据结构往往都占有一组连续的内存单元。用“地址”这个概念并不能很好地描述一种数据类型或数据结构，而“指针”虽然实际上也是一个地址，但它却是一个数据结构的首地址，它是“指向”一个数据结构的，因而概念更为清楚，表示更为明确。 这也是引入“指针”概念的一个重要原因。

变量的指针就是变量的地址。存放变量地址的变量是指针变量。即在C语言中，允许用一个变量来存放指针，这种变量称为指针变量。因此，一个指针变量的值就是某个变量的地址或称为某变量的指针。

为了表示指针变量和它所指向的变量之间的关系，在程序中用*符号表示“指向”，例如，i_pointer代表指针变量，而*i_pointer是i_pointer所指向的变量。因此，下面两个语句作用相同：

i=3;*i_pointer=3;

第2个语句的含义是将3赋给指针变量i_pointer所指向的变量。

定义指针变量

定义指针变量的一般形式为：

类型说明符 *变量名;

其中，*表示这是一个指针变量，变量名是一个合法的标识符，类型说明符表示该指针变量所指向的变量的数据类型。例如：

int *p1;

表示p1是一个指针变量，它的值是某个整型变量的地址。或者说p1指向一个整型变量。至于p1究竟指向哪一个整型变量，应由向p1赋予的地址来决定。再如：

int *p2;  //p2是指向整型变量的指针变量
float *p3;  //p3是指向浮点变量的指针变量
char *p4;  //p4是指向字符变量的指针变量

应该注意的是，一个指针变量只能指向同类型的变量，如 p3 只能指向浮点变量，不能时而指向一个浮点变量，时而又指向一个字符变量。

指针变量的引用

指针变量同普通变量一样，使用之前不仅要定义说明，而且必须赋予具体的值（初始化）。未初始化的指针变量的值是垃圾值，没有意义，不能使用，例如：

#include <stdio.h>
int main(){
    int *p;
    printf("%X\n", p);  //十六进制输出
    return 0;
}

运行结果：
7EFDE000

以上输出是在64位操作系统上的结果，如果你的操作系统是32位，那么输出只有4位，如23EB、983A等，为什么呢？

指针变量的赋值只能赋予地址，决不能赋予任何其它数据，否则将引起错误。在C语言中，变量的地址是由编译器分配的，对用户完全透明，用户不能控制变量的具体地址。

两个有关的运算符：

• &：取地址运算符；
• *：指针运算符（或称“间接访问” 运算符）。

C语言中提供了地址运算符&来获取变量的地址。其一般形式为：

&变量名;

如&a表示变量a的地址，&b表示变量b的地址。变量本身必须预先定义。

设有指向整型变量的指针变量p，如要把整型变量 a 的地址赋予p可以有以下两种方式。

1) 指针变量初始化的方法：

int a=10;int *p=&a;

2) 赋值语句的方法：

int a=10;int *p;p=&a;

不允许把一个数字直接赋予指针变量，故下面的赋值是错误的：

int *p;p=1000;

被赋值的指针变量前不能再加*说明符，如写为*p=&a也是错误的。假设：

int i=200, x;int *ip;

我们定义了两个整型变量i、x，还定义了一个指向整型数的指针变量ip。i、x中可存放整数，而ip中只能存放整型变量的地址。我们可以把 i 的地址赋给 ip：

ip=&i;

此时指针变量 ip 指向整型变量 i，假设变量 i 的地址为1800，这个赋值可形象理解为下图所示的联系：


以后我们便可以通过指针变量 ip 间接访问变量 i，例如：

x = *ip;

运算符*访问以 ip 为地址的存储区域，而 ip 中存放的是变量 i 的地址，因此，*ip 访问的是地址为 1800 的存储区域（因为是整数，实际上是从1800开始的两个字节），它就是 i 所占用的存储区域，所以上面的赋值表达式等价于：

x = i;

另外，指针变量和一般变量一样，存放在它们之中的值是可以改变的，也就是说可以改变它们的指向。例如：

int i, j, *p1, *p2;
i = 'a';
j = 'b';
p1 = &i;
p2 = &j;

可建立如下图所示的联系：


这时赋值表达式：

p2=p1;

就使p2与p1指向同一对象i，此时*p2就等价于i，而不是j，图所示：


如果执行如下表达式：

*p2=*p1;

则表示把p1指向的内容赋给p2所指的区域，此时就变成下图所示：


通过指针访问它所指向的变量是以间接访问的形式进行的，所以比直接访问一个变量要费时间，而且不直观，因为通过指针要访问哪一个变量，取决于指针的值（即指向），例如*p2=*p1;实际上就是j=i;，前者不仅速度慢而且目的不明。但由于指针是变量，我们可以通过改变它们的指向，以间接访问不同的变量，这给程序员带来灵活性，也使程序代码编写得更为简洁和有效。

指针变量可出现在表达式中，设：

int x, y, *px = &x;

指针变量px指向整数x，则*px可出现在x能出现的任何地方。例如：

y=*px+5;  //表示把x的内容加5并赋给y
y=++*px;  //px的内容加上1之后赋给y，++*px相当于++(*px)
y=*px++;  //相当于y=*px; px++

指针使用举例：

#include <stdio.h>
int main(){
    int a=100, b=10;
    int *pointer_1, *pointer_2;
    pointer_1 = &a;
    pointer_2 = &b;
    printf("%d, %d\n", a, b);
    printf("%d, %d\n", *pointer_1, *pointer_2);
    return 0;
}

运行结果：
100, 10
100, 10

对程序的说明：

1. 在开头处虽然定义了两个指针变量pointer_1和pointer_2，但它们并未指向任何一个整型变量。只是提供两个指针变量，规定它们可以指向整型变量。程序第5、6行的作用就是使pointer_1指向a，pointer_2指向b。
2. 第8行的*pointer_1和*pointer_2就是变量a和b。最后两个printf函数作用是相同的。
3. 程序中有两处出现*pointer_1和*pointer_2，请区分它们的不同含义。
4. 程序第5、6行的pointer_1=&a和pointer_2=&b不能写成*pointer_1=&a和*pointer_2=&b。

请对下面关于“&”和“*”的问题进行考虑：

1. 如果已经执行了“pointer_1=&a；”语句，则&*pointer_1是什么含义？
2. *&a含义是什么？
3. (pointer_1)++和pointer_1++的区别？

【示例】输入a和b两个整数，按先大后小的顺序输出。

#include <stdio.h>
int main(){
    int *max, *min,*tmp, a, b;
    scanf("%d, %d",&a, &b);
    max = &a;
    min = &b;
    if(*max < *min){
        // 交换指针变量的值，tmp 为临时变量
        tmp = max;
        max = min;
        min = tmp;
    }
    printf("a=%d, b=%d\n", a, b);
    printf("max=%d, min=%d\n", *max, *min);
    return 0;
}

运行结果：
10, 20↙
a=10, b=20
max=20, min=10

函数的参数不仅可以是整型、实型、字符型等数据，还可以是指针类型。它的作用是将一个变量的地址传送到另一个函数中。

【示例】输入两个整数，按大小顺序输出。

#include <stdio.h>
// 交换两个数
void swap(int *p1, int *p2){
    int temp;  //临时变量
    temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}
int main(){
    int a, b;
    int *pointer_1, *pointer_2;
    scanf("%d, %d",&a, &b);
    pointer_1 = &a;
    pointer_2 = &b;
    if(a<b){
        swap(pointer_1, pointer_2);
    }
    printf("\n%d, %d\n",a, b);
    return 0;
}

运行结果：
10, 20
20, 10

对程序的说明：
1) swap是自定义函数，它的作用是交换两个变量（a和b）的值。swap函数的形参p1、p2是指针变量。程序运行时，先执行main函数，输入a和b的值。然后将a和b的地址分别赋给指针变量pointer_1和pointer_2，使pointer_1指向a，pointer_2指向b。

2) 接着执行if语句，由于a<b，因此执行swap函数。注意实参pointer_1和pointer_2是指针变量，在函数调用时，将实参变量的值传递给形参变量。采取的依然是“值传递”方式。因此虚实结合后形参p1的值为&a，p2的值为&b。这时p1和pointer_1指向变量a，p2和pointer_2指向变量b。

3) 接着执行执行swap函数的函数体使*p1和*p2的值互换，也就是使a和b的值互换。函数调用结束后，p1和p2不复存在（已释放）。

4) 最后在main函数中输出的a和b的值是已经过交换的值。请注意交换*p1和*p2的值是如何实现的。请找出下列程序段的错误：

void swap(int *p1,int *p2){
    int *temp;
    *temp=*p1;  //此语句有问题
    *p1=*p2;
    *p2=temp;
}

请考虑下面的函数能否实现实现a和b互换。

void swap(int x,int y){
    int temp;
    temp=x;
    x=y;
    y=temp;
}

如果在main函数中用“swap(a, b);”调用swap函数，会有什么结果呢？

【示例】对上面的代码进行修改。

#include <stdio.h>
// 交换两个数
void swap(int *p1,int *p2){
    int *p;
    p = p1;
    p1 = p2;
    p2 = p;
}
int main(){
    int a, b;
    int *pointer_1, *pointer_2;
    scanf("%d, %d",&a, &b);
    pointer_1 = &a;
    pointer_2 = &b;
    if(a<b){
        swap(pointer_1, pointer_2);
    }
    printf("\n%d, %d\n",a, b);
    return 0;
}

运行结果：
10, 20
10, 20

为什么这里没有交换？

因为这里只是定义了指针p，并且这个交换函数只是交换了p1和p2指针的指向，而指针指向的内容并没有发生改变。

而int temp;
temp=*p1;
*p1=*p2;
*p2=temp; 

这么写并不是交换了a,b两个变量的地址，而是实实在在交换了a,b两个变量的值。swap函数传递进来的是两个变量的指针变量，也可以理解为两个变量的地址。实参传递地址到形参，那么形参实际上也指向了a,b两个变量。此时对形参的操作实际上就是对a,b两个变量的操作。实际上就是改变了两个变量的值。

而void swap2(int p1,int p2){
int temp;
temp=p1;
p1=p2;
p2=temp;
} 

交换函数这么写的话肯定不行的。很简单，实参向形参传参，形参具有了实参同样的值，但在swap2函数中只是交换了形参的值，函数执行完形参即被销毁了，而实参没受到影响，故这样做不行。

最后再说说交换函数用指针的关键点，swap函数参数都是指针，就要求实参传递的是要交换变量的指针即变量地址，这样在swap函数里操作的是两个实参而不是形参。