教案-指针.doc

6.1 指针的概念
为了说清楚什么是指针，必须弄清楚数据在内存中是如何存储的，又是如何读取的。
如果在程序中定义了一个变量，在编译时就给这个变量分配内存单元。系统根据程序中定义的变量类型，分配一定长度的空间。例如，C++编译系统一般为整型变量分配4个字节，为单精度浮点型变量分配4个字节，为字符型变量分配1个字节。内存区的每一个字节有一个编号，这图6.1就是“地址”。

请务必弄清楚一个内存单元的地址与内存单元的内容这两个概念的区别。在程序中一般是通过变量名来对内存单元进行存取操作的。其实程序经过编译以后已经将变量名转换为变量的地址，对变量值的存取都是通过地址进行的。这种按变量地址存取变量值的方式称为直接存取方式，或直接访问方式。
还可以采用另一种称为间接存取(间接访问)的方式。可以在程序中定义这样一种特殊的变量，它是专门用来存放地址的。
图6.2是直接访问和间接访问的示意图。为了将数值3送到变量中，可以有两种方法：
(1) 直接将数3送到整型变量ｉ所标识的单元中。见图6.2(a)。
(2) 将3送到指针变量i_pointer所指向的单元（这就是变量i所标识的单元）中。见图6.2(b)。

图6.2

所谓指向,就是通过地址来体现的。
由于通过地址能找到所需的变量单元，因此可以说，地址指向该变量单元。因此将地址形象化地称为“指针”。一个变量的地址称为该变量的指针。
如果有一个变量是专门用来存放另一变量地址（即指针）的，则它称为指针变量。指针变量的值（即指针变量中存放的值）是地址（即指针）。
6.2 变量与指针
指针变量是一种特殊的变量，它和以前学过的其他类型的变量的不同之处是： 用它来指向另一个变量。为了表示指针变量和它所指向的变量之间的联系，在C++中用“*”符号表示指向，例如，i_pointer是一个指针变量，而*i_pointer表示i_pointer所指向的变量，见图6.3。
下面两个语句作用相同：
① i=3;
② *i_pointer=3;

图6.3
6.2.１ 定义指针变量
C++规定所有变量在使用前必须先定义，即指定其类型。在编译时按变量类型分配存储空间。对指针变量必须将它定义为指针类型。先看一个具体例子：
int i,j; //定义整型变量i,j
int *pointer_1, *pointer_2； //定义指针变量*pointer_1,*pointer_2
第2行开头的int是指： 所定义的指针变量是指向整型数据的指针变量。也就是说，指针变量pointer_1和pointer_2只能用来指向整型数据(例如i和j)，而不能指向浮点型变量a和b。这个int就是指针变量的基类型。指针变量的基类型用来指定该指针变量可以指向的变量的类型。
定义指针变量的一般形式为
基类型 *指针变量名；
下面都是合法的定义：
float *pointer_3; // pointer_3是指向单精度型数据的指针变量
char *pointer_4; // pointer_4是指向字符型数据的指针变量
请注意： 指针变量名是pointer_3和pointer_4，而不是*pointer_3和*pointer_4，即“*”不是指针变量名的一部分，在定义变量时在变量名前加一个“*”表示该变量是指针变量。
那么，怎样使一个指针变量指向另一个变量呢？只需要把被指向的变量的地址赋给指针变量即可。例如：
pointer_1=&i; //将变量i的地址存放到指针变量pointer_1中
pointer_2=&j; //将变量j的地址存放到指针变量pointer_2中
这样，pointer_1就指向了变量i，pointer_2就指向了变量j。见图6.4。

图6.4
一般的C++编译系统为每一个指针变量分配4个字节的存储单元，用来存放变量的地址。
在定义指针变量时要注意：
(1) 不能用一个整数给一个指针变量赋初值。
(2) 在定义指针变量时必须指定基类型。
6.2.2 引用指针变量
有两个与指针变量有关的运算符：
(1) ＆取地址运算符。
(2) *指针运算符（或称间接访问运算符）。
例如： &a为变量a的地址，*p为指针变量p所指向的存储单元。
例6.1 通过指针变量访问整型变量。
#include <iostream>
using namespace std;
int main( )
{int a,b; //定义整型变量a,b
int *pointer_1,*pointer_2; //定义指针变量*pointer_1,*pointer_2
a=100;b=10; //对a,b赋值
pointer_1=&a; //把变量ａ的地址赋给pointer_1
pointer_2=&b; //把变量ａ的地址赋给pointer_2
cout<<a<<″ ″<<b<<endl; //输出a和b的值
cout<<*pointer_1<<″ ″<<*pointer_2<<endl; //输出*pointer_1和*pointer_2的值
return 0;
}
运行结果为
100 10 (a和b的值)
100 10 (*pointer_1和*pointer_2的值)
请对照图6.5分析。

下面对“&”和“*”运算符再做些说明：
(1) 如果已执行了“pointer_1=&a;”语句，请问&*pointer_1的含义是什么？“&”和“*”两个运算符的优先级别相同，但按自右至左方向结合，因此先进行*pointer_1的运算，它就是变量a，再执行&运算。因此，&*pointer_1与&a相同，即变量a的地址。
如果有pointer_２=&*pointer_1；它的作用是将&a(a的地址)赋给pointer_2，如果pointer_2原来指向b，经过重新赋值后它已不再指向b了，而也指向了ａ，见图6.6。图6.6(a)是原来的情况，图6.6(b)是执行上述赋值语句后的情况。

(2) *&a的含义是什么？先进行&a的运算，得a的地址，再进行*运算，即&a所指向的变量，*&a和*pointer_1的作用是一样的（假设已执行了“pointer_1=&a;”），它们等价于变量a。即*&a与a等价，见图6.7。

例6.2 输入a和b两个整数，按先大后小的顺序输出a和b(用指针变量处理)。
解此题的思路是： 设两个指针变量p1和p2，使它们分别指向a和b。使p1指向a和b中的大者，p2指向小者，顺序输出*p1,*p2就实现了按先大后小的顺序输出a和b。按此思路编写程序如下：
#include <iostream>
using namespace std;
int main( )
{
int *p1,*p2,*p,a,b;
cin>>a>>b; //输入两个整数
p1=&a; //使p1指向a
p2=&b; //使p2指向b
if(a<b) //如果a<b就使p1与p2的值交换
{p=p1;p1=p2;p2=p;} //将p1的指向与p2的指向交换
cout<<″a=″<<a<<″ b=″<<b<<endl;
cout<<″max=″<<*p1<<″ min=″<<*p2<<endl;
return 0;
}
运行情况如下：
4578↙
a=45 b=78
max=78 min=45
输入a的值45，b的值78，由于a<b，将p1的值和p2的值交换，即将p1的指向与p2的指向交换。交换前的情况见图6.8(a)，交换后的情况见图6.8(b)。

请注意，这个问题的算法是不交换整型变量的值，而是交换两个指针变量的值。
6.2.3 指针作为函数参数
函数的参数不仅可以是整型、浮点型、字符型等数据，还可以是指针类型。它的作用是将一个变量的地址传送给被调用函数的形参。
例6.3 题目同例6.2，即对输入的两个整数按大小顺序输出。
这里用函数处理，而且用指针类型的数据作函数参数。
程序如下：
#include <iostream>
using namespace std;
int main( )
{ void swap(int *p1,int *p2); //函数声明
int *pointer_1,*pointer_2,a,b; //定义指针变量pointer_1,pointer_2，整型变量a,b
cin>>a>>b;
pointer_1=&a; //使pointer_1指向a
pointer_2=&b; //使pointer_2指向b
if(a<b) swap(pointer_1,pointer_2); //如果a<b，使*pointer_1和*pointer_2互换
cout<<″max=″<<a<<″ min=″<<b<<endl;//a已是大数，b是小数
return 0;
}

void swap(int *p1,int *p2) //函数的作用是将*p1的值与*p2的值交换
{ int temp;
temp=*p1;
*p1=*p2;
*p2=temp;
}
运行情况如下：
45 78↙
max=78 min=45
请注意： 不要将main函数中的swap函数调用写成
if(a<b) swap(*pointer_1,*pointer_2);

请注意交换*p1和*p2的值是如何实现的。如果写成以下这样就有问题了：
void swap(int *p1,int *p2)
{int *temp；
*temp＝*p1； //此语句有问题
*p1=*p2;
*p2=*temp；
｝
本例采取的方法是交换a和b的值，而p1和p2的值不变。这恰和例6.2相反。
可以看到，在执行swap函数后，主函数中的变量a和b的值改变了。这个改变不是通过将形参值传回实参来实现的。请读者考虑一下能否通过调用下面的函数实现a和b互换。
void swap（int x,int y）
{int temp;
temp=x；
x=y;
y=temp;
}
在main函数中用“swap(a,b);”调用swap函数，会有什么结果呢？在函数调用时，a的值传送给x，b的值传送给y，如图6.10(a)所示。执行完swap函数最后一个语句后，x和y的值是互换了，但main函数中的a和b并未互换，如图6.10(b)所示。也就是说由于虚实结合是采取单向的“值传递”方式，只能从实参向形参传数据，形参值的改变无法回传给实参。

为了使在函数中改变了的变量值能被main函数所用，不能采取把要改变值的变量作为参数的办法，而应该用指针变量作为函数参数。在函数执行过程中使指针变量所指向的变量值发生变化，函数调用结束后，这些变量值的变化依然保留下来，这样就实现了“通过调用函数使变量的值发生变化，在主调函数中使用这些改变了的值”的目的。
如果想通过函数调用得到n个要改变的值，可以采取下面的步骤： ①在主调函数中设n个变量，用n个指针变量指向它们；②编写被调用函数，其形参为n个指针变量，这些形参指针变量应当与主调函数中的n个指针变量具有相同的基类型；③在主调函数中将n个指针变量作实参，将它们的值(是地址值)传给所调用函数的n个形参指针变量，这样，形参指针变量也指向这n个变量；④通过形参指针变量的指向，改变该n个变量的值；⑤在主调函数中就可以使用这些改变了值的变量。
请注意，不能企图通过改变形参指针变量的值而使实参指针变量的值改变。请分析下面程序：
#include <iostream>
using namespace std;
int main( )
{ void swap(int *p1,int *p2);
int *pointer_1,*pointer_2,a,b;
cin>>a>>b;
pointer_1=&a;
pointer_2=&b;
if(a<b) swap(pointer_1,pointer_2);
cout<<″max=″<<a<<″ min=″<<b<<endl;
return 0;
}

void swap(int *p1,int *p2)
{ int *temp;
temp=p1;
p1=p2;
p2=temp;
}

实参变量和形参变量之间的数据传递是单向的“值传递”方式。指针变量作函数参数也要遵循这一规则。调用函数时不会改变实参指针变量的值，但可以改变实参指针变量所指向变量的值。
函数的调用可以（而且只可以）得到一个返回值（即函数值），而使用指针变量作函数参数，就可以通过指针变量改变主调函数中变量的值，相当于通过函数调用从被调用的函数中得到多个值。如果不用指针变量是难以做到这一点的。
例6.4 输入a,b,c 3个整数，按由大到小的顺序输出。
用上面介绍的方法，用3个指针变量指向3个整型变量，然后用swap函数来实现互换3个整型变量的值。
程序如下：
#include <iostream>
using namespace std;
int main( )
{ void exchange(int *,int *,int *); //对exchange函数的声明
int a,b,c,*p1,*p2,*p3;
cin>>a>>b>>c; //输入3个整数

p1=&a;p2=&b;p3=&c; //指向3个整型变量
exchange(p1,p2,p3); //交换p1,p2,p3指向的3个整型变量的值
cout<<a<<″ ″<<b<<″ ″<<c<<endl; //按由大到小的顺序输出3个整数
}

void exchange(int *q1,int *q2,int *q3)
{void swap(int *,int *); //对swap函数的声明
if(*q1<*q2) swap(q1,q2); //调用swap,将q1与q2所指向的变量的值互换
if(*q1<*q3) swap(q1,q3); //调用swap,将q1与q3所指向的变量的值互换
if(*q2<*q3) swap(q2,q3); //调用swap,将q2与q3所指向的变量的值互换
}

void swap(int *pt1,int *pt2) //将pt1与pt2所指向的变量的值互换
{int temp;
temp=*pt1;
*pt1=*pt2;
*pt2=temp;
}
运行情况如下：
12 -56 87↙
87 12 -56