第8章 善于利用指针

学习 C 语言的指针既简单又有趣。通过指针，可以简化一些 C 编程任务的执行，还有一些任务，如动态内存分配，没有指针是无法执行的。所以，想要成为一名优秀的 C 程序员，学习指针是很有必要的。

正如您所知道的，每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号（&）运算符访问的地址，它表示了在内存中的一个地址。请看下面的实例，它将输出定义的变量地址：

 

#include <stdio.h>

 

int main ()

{

   int  var1;

   char var2[10];

 

   printf("var1 变量的地址： %p\n", &var1  );

   printf("var2 变量的地址： %p\n", &var2  );

 

   return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

var1 变量的地址： 0x7fff5cc109d4

var2 变量的地址： 0x7fff5cc109de

通过上面的实例，我们了解了什么是内存地址以及如何访问它。接下来让我们看看什么是指针。

8.1什么是指针？

指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。

指针变量声明的一般形式为：type *var-name;

在这里，type 是指针的基类型，它必须是一个有效的 C 数据类型，var-name 是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。以下是有效的指针声明：

int    *ip;    /* 一个整型的指针 */

double *dp;    /* 一个 double 型的指针 */

float  *fp;    /* 一个浮点型的指针 */

char   *ch;     /* 一个字符型的指针 */

所有指针的值的实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，都是一样的，都是一个代表内存地址的长的十六进制数。不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

8.2指针变量

8.2.1 使用指针变量的例子

#include <stdio.h>

int main()

{ int a=100,b=10;

//定义整型变量a,b，并初始化

int *pointer_1,*pointer_2;

//定义指向整型数据的指针变量pointer_1, pointer_2

pointer_1=&a; //把变量a的地址赋给指针变量pointer_1

       pointer_2=&b;   //把变量b的地址赋给指针变量pointer_2

printf("a=%d,b=%d\n",a,b); //输出变量a和b的值

printf("*pointer_1=%d,*pointer_2=%d\n",*pointer_1,*pointer_2);

//输出变量a和b的值

return 0;

}

运行结果：

 

上面变量对应的关系，如图：

 

 

注：定义指针变量时，左侧应有类型名，否则就不是定义指针变量。也称为基类型

8.2.2 怎样定义指针变量

定义指针的一般形式为：

类型名 *指针变量名;

如：

int *pointer_1;

注意：左端的int是在定义指针变量时必须指定的"基类型".换个说法就是类型名一定要有，否则是错误的定义。

如：

*pointer_1; //企图定义pointer_1为指针变量。出错

int *pointer_1; //正确，必须指定指针变量的基类型

 

说明：在定义指针变量时要注意一下几点：

(1) 指针变量前面的"*"表示该变量的类型为指针型变量。

(2) 在定义指针变量时必须制定基类型(即类型名)

一个变量的指针的含义包括两个方面，一是以存储单元编号表示的地址(如编号为2000的字节)，一是它指向的存储单元的数据类型(如int,char,float等)。

(3)如何表示指针类型

指向整型数据的指针类型表示为"int*"，读作"指向int的指针"或简称"int指针"

(4) 指针变量中只能存放地址(地址)，不要讲一个整数赋给一个指针变量。如：

*pointer_1 = 100; //pointer_1是指针变量，100是整数，不合法的赋值

8.2.3 怎样引用指针变量

(1) 给指针变量赋值。如：

p = &a; //把a的地址赋给指针变量a

(2) 引用指针变量指向的变量

如果已执行"p = &a;"，即指针变量p指向了整型变量a,则

printf("%d",*p);

作用：以整数形式输出指针变量p所指向的变量的值，即变量a的值

注：一定要带'*'，否则输出地址

也可以用指针的形式对a重新赋值

*p = 1;

表示将1赋值给p当前p指向的变量，因为p指向变量a，则相当于把1赋值给a，即和"a = 1"等价。

(3) 引用指针变量的值。如：

printf("%o",p);

作用：以八进制数形式输出指针变量p的值，如果p指向了a，就是输出了a的地址,即&a.

printf("%o",&a);   <==> printf("%o",p); //两者等价

例：

#include <stdio.h>

int main()

{

int *p,a;

a = 100;

p = &a;

printf("%o\n",p);

printf("%o\n",&a);

 

}

 

要熟练掌握两个有关的运算符：

(1) ＆取地址运算符。&a是变量a的地址。

(2) * 指针运算符（或称“间接访问”运算符），*p代表指针变量p指向的对象。

 

#include <stdio.h>

int main()

{ int *p1,*p2,*p,a,b;     //p1,p2的类型是int *类型

printf("please enter two integer numbers:");

       scanf("%d,%d",&a,&b);                       //输入两个整数

p1=&a;       //使p1指向变量a

p2=&b;       //使p2指向变量b

if(a<b)       //如果a<b

{ p=p1;p1=p2;p2=p;}   //使p1与p2的值互换

printf("a=%d,b=%d\n",a,b);   //输出a,b

printf("max=%d,min=%d\n",*p1,*p2); //输出p1和p2所指向的变量的值

return 0;

}

运行结果：

 

指针在过程中的变化：

 

 

8.2.4 指针变量作为函数参数

例：对输入的两个整数按大小顺序输出。现用函数处理，而且用指针类型的数据作函数参数。

#include <stdio.h>

void swap(int *p1,int *p2);    //对swap函数的声明

int main()

{

int a,b;

int *pointer_1,*pointer_2; //定义两个int *型的指针变量

printf("please enter a and b:");

scanf("%d,%d",&a,&b);  //输入两个整数

pointer_1=&a;   //使pointer_1指向a

       pointer_2=&b;                 //使pointer_2指向b

if(a<b) swap(pointer_1,pointer_2); //如果a<b，调用swap函数

printf("max=%d,min=%d\n",a,b);  //输出结果

return 0;

}

 

void swap(int *p1,int *p2)   //定义swap函数

{ int temp;

temp=*p1;     //使*p1和*p2互换

*p1=*p2;

*p2=temp;

}

运行结果：

 

指针变量pointer_1 pointer_2的变量过程

 

 

注：要注意区分以下三种形式，可自己调试，增加理解

void swap(int *p1,int *p2)//定义swap函数 { int temp; temp=*p1;//使*p1和*p2互换 *p1=*p2; *p2=temp; }

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

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

下面有一个问题需要注意，也可以直接跳过，如果想提升可以理解，以理解为主，不需要死记硬背。

指针变量作为函数参数

函数的调用可以（而且只可以）得到一个返回值（即函数值），而使用指针变量作参数，可以得到多个变化了的值。如果不用指针变量是难以做到这一点的。要善于利用指针法。

如果想通过函数调用得到n个要改变的值，可以这样做:

 

1.在主调函数中设n个变量，用n个指针变量指向它们；

 

2.设计一个函数，有n个指针形参。在这个函数中改变这n个形参的值；

 

3.在主调函数中调用这个函数，在调用时将这n个指针变量作实参，将它们的值，也就是相关变量的地址传给该函数的形参；

 

3.在执行该函数的过程中，通过形参指针变量，改变它们所指向的n个变量的值；

 

5.主调函数中就可以使用这些改变了值的变量。

例：输入3个整数a,b,c，要求按由大到小的顺序将它们输出。用函数实现。

#include <stdio.h>

int main()

{ void exchange(int *q1, int *q2, int *q3); //函数声明

int a,b,c,*p1,*p2,*p3;

printf("please enter three numbers:");

scanf("%d,%d,%d",&a,&b,&c);

p1=&a;p2=&b;p3=&c;

exchange(p1,p2,p3);

printf("The order is:%d,%d,%d\n",a,b,c);

return 0;

}

 

void exchange(int *q1, int *q2, int *q3) //将3个变量的值交换的函数

{ void swap(int *pt1, int *pt2);  //函数声明

if(*q1<*q2) swap(q1,q2);  //如果a<b，交换a和b的值

if(*q1<*q3) swap(q1,q3);  //如果a<c，交换a和c的值

if(*q2<*q3) swap(q2,q3);  //如果b<c，交换b和c的值

}

 

void swap(int *pt1, int *pt2)   //交换2个变量的值的函数

{ int temp;

temp=*pt1;    //交换*pt1和*pt2变量的值

*pt1=*pt2;

*pt2=temp;

}

运行结果：

 

 

8.3 通过指针引用数组

8.3.1 数组元素的指针

数组元素的指针就是素组元素的地址。

int a[10]={1,3,5,7,9,11,13,15,17,19};  //定义a为包含10个整型数据的数组

int *p;         //定义p为指向整型变量的指针变量

p=&a[0];        //把a[0]元素的地址赋给指针变量p

引用数组元素的方式

(1) 下标法

(2) 指针法

p=&a[0]; //p的值是a[0]的地址

等价于

p=a; //p的值是数组a首元素(即a[0])的地址

注：程序中的数组名不代表整个数组，只代表数组首元素的地址。

以下是指针变量的初始化方式：

(1) 在定义后再单独进行初始化

int *p;

p=&a[0]; //不应写成*p=&a[0];

(2) 在定义时直接进行初始化

int *p=&a[0];

等价于

int *p=a;

以上三种的作用：将a数组首元素(即a[0])的地址赋值给指针变量p(而不是赋给*p)

8.3.2 在引用数组元素时指针的运算

在指针已指向一个数组元素时，可以对指针进行以下运算：

1.加一个整数(用+或+=)，如p+1，表示指向同一数组中的下一个元素；

 

2.减一个整数(用-或-=)，如p-1，表示指向同一数组中的上一个元素；

 

3.自加运算，如p++，++p；

 

4.自减运算，如p--，--p。

 

两个指针相减，如p1-p2(p1和p2都指向同一数组中的元素时才有意义)，结果为两个地址之差除以数组元素的长度。

注：两个地址不能相加，如p1+p2是无实际意义的。

 

说明：

*(p+i)或*(a+i)是p+i或a+i所指向的数组元素，即a[i]。

p的初值为&a[0]，则p+i和a+i就是数组元素a[i]的地址

[]实际上是变址运算符，即将a[i]按a+i计算地址，然后找出此地址单元中的值。

例：有一个整型数组a，有10个元素，要求输出数组中的全部元素。

//下标法 #include <stdio.h> int main() { int a[10]; int i; printf("please enter 10 integer numbers:"); for(i=0;i<10;i++) scanf("%d",&a[i]); for(i=0;i<10;i++) printf("%d ",a[i]); //数组元素用数组名和下标表示 printf("%\n"); return 0; }

//通过数组名计算数组元素地址，找出元素的值 #include <stdio.h> int main() { int a[10]; int i; printf("please enter 10 integer numbers:"); for(i=0;i<10;i++) scanf("%d",&a[i]); for(i=0;i<10;i++) printf("%d ",*(a+i)); //通过数组名和元素序号计算元素地址找到该元素 printf("\n"); return 0; }

//用指针变量指向数组元素 #include <stdio.h> int main() { int a[10]; int *p,i; printf("please enter 10 integer numbers:"); for(i=0;i<10;i++) scanf("%d",&a[i]); for(p=a;p<(a+10);p++) printf("%d ",*p); //用指针指向当前的数组元素 printf("\n"); return 0; }

说明：

第(1)和第(2)种方法执行效率是相同的。C编译系统是将a[i]转换为*(a+i)处理的，即先计算元素地址。因此用第(1)和第(2)种方法找数组元素费时较多。

 

第(3)种方法比第(1)、第(2)种方法快，用指针变量直接指向元素，不必每次都重新计算地址，像p++这样的自加操作是比较快的。这种有规律地改变地址值(p++)能大大提高执行效率。

 

例：通过指针变量输出整型数组a的10个元素。

#include <stdio.h> int main() { int *p,i,a[10]; p=a;    //p指向a[0]  ① printf("please enter 10 integer numbers:"); for(i=0;i<10;i++) scanf("%d",p++); //输入10个整数给a[0]~a[9] for(i=0;i<10;i++,p++) printf("%d ",*p); //想输出a[0]~a[9] ② printf("\n"); return 0; }

#include <stdio.h> int main() { int i,a[10],*p=a; //p的初值是a，p指向a[0] printf("please enter 10 integer numbers:"); for(i=0;i<10;i++) scanf("%d",p++); p=a;    //重新使p指向a[0] for(i=0;i<10;i++,p++) printf("%d ",*p); printf("\n"); return 0; }

运行上面两个代码看看有何区别，造成这种区别的原因是什么？

答：第一种是因为指针已经到了数组的末尾，继续循环则超出了数组的范围，则会直接输出P对应的地址值。如图所示：

 

 

技巧：

设p开始时指向数组a的首元素(即p=a)

(1)

p++; //使p指向下一元素a[1]

*p; //得到下一个元素a[1]的值

(2)

*p++; /*由于++和*同优先级，结合方向自右而左，因此它等价于*(p++)。先引用p的值，实现*p的运算，然后再使p自增1*/

(3)

*(p++); //先取*p值，然后使p加1

*(++p); //先使p加1，再取*p

(4)

++(*p); /*表示p所指向的元素值加1，如果p=a, 则相当于++a[0]，若a[0]的值为3，则a[0]的值为4。注意: 是元素a[0]的值加1，而不是指针p的值加1*/

(5)

如果p当前指向a数组中第i个元素a[i]，则:

*(p--) //相当于a[i--]，先对p进行“*”运算，再使p自减

*(++p) //相当于a[++i]，先使p自加，再进行“*”运算

*(--p) //相当于a[--i]，先使p自减，再进行“*”运算

8.3.4 用数组名作函数参数

以变量名和数组名作为函数参数的比较

 

 

C语言调用函数时虚实结合的方法都是采用“值传递”方式，当用变量名作为函数参数时传递的是变量的值，当用数组名作为函数参数时，由于数组名代表的是数组首元素地址，因此传递的值是地址，所以要求形参为指针变量。

 

注意：实参数组名代表一个固定的地址，或者说是指针常量，但形参数组名并不是一个固定的地址，而是按指针变量处理。

 

例：将数组a中n个整数按相反顺序存放

#include <stdio.h> int main() { void inv(int x[],int n); //inv函数声明 int i,a[10]={3,7,9,11,0,6,7,5,4,2}; printf("The original array:\n"); for(i=0;i<10;i++) printf("%d ",a[i]); //输出未交换时数组各元素的值 printf("\n"); inv(a,10);    //调用inv函数，进行交换 printf("The array has been inverted:\n"); for(i=0;i<10;i++) printf("%d ",a[i]); //输出交换后数组各元素的值 printf("\n"); return 0; } void inv(int x[],int n)  //形参x是数组名 { int temp,i,j,m=(n-1)/2; for(i=0;i<=m;i++) { j=n-1-i; temp=x[i]; x[i]=x[j]; x[j]=temp; //把x[i]和x[j]交换 } return; }

#include <stdio.h> int main() { void inv(int *x,int n); int i,a[10]={3,7,9,11,0,6,7,5,4,2}; printf("The original array:\n"); for(i=0;i<10;i++) printf("%d ",a[i]); printf("\n"); inv(a,10); printf("The array has been inverted:\n"); for(i=0;i<10;i++) printf("%d ",a[i]); printf("\n"); return 0; }   void inv(int *x,int n)   //形参x是指针变量 { int *p,temp,*i,*j,m=(n-1)/2; i=x; j=x+n-1; p=x+m; for(;i<=p;i++,j--) { temp=*i; *i=*j; *j=temp;} //*i与*j交换 return; }

以上两种方式所得结果是一致的，只是实现的形式有区别。所得结果都为下图所示：

说明：以下的形式要认识，以下四种都是等价的

 

 

例：将数组a中n个整数按相反顺序存放，用指针变量作实参。

#include <stdio.h>

int main()

{ void inv(int *x,int n); //inv函数声明

int i,arr[10],*p=arr;  //指针变量p指向arr[0]

printf("The original array:\n");

for(i=0;i<10;i++,p++)

scanf("%d",p);  //输入arr数组的元素

printf("\n");

p=arr;    //指针变量p重新指向arr[0]

inv(p,10);    //调用inv函数，实参p是指针变量

printf("The array has been inverted:\n");

for(p=arr;p<arr+10;p++)

printf("%d ",*p);

printf("\n");

return 0;

}

 

void inv(int *x,int n)         //定义inv函数，形参x是指针变量

{ int *p,m,temp,*i,*j;

m=(n-1)/2;

i=x;j=x+n-1;p=x+m;

for(;i<=p;i++,j--)

{ temp=*i;*i=*j;*j=temp;}

return;

}

注：如果用指针变量作实参，必须先使指针变量有确定值，指向一个已定义的对象。

 

例：用指针方法对10个整数按由大到小顺序排序。（选择排序法）

//形参是数组 #include <stdio.h> int main() { void sort(int x[],int n); //sort函数声明 int i,*p,a[10]; p=a;     //指针变量p指向a[0] printf("please enter 10 integer numbers:"); for(i=0;i<10;i++) scanf("%d",p++); //输入10个整数 p=a; //指针变量p重新指向a[0] sort(p,10);   //调用sort函数 for(p=a,i=0;i<10;i++) { printf("%d ",*p); //输出排序后的10个数组元素 p++; } printf("\n"); return 0; }   void sort(int x[],int n)//x是形参数组名 { int i,j,k,t; for(i=0;i<n-1;i++) { k=i; for(j=i+1;j<n;j++) if(x[j]>x[k]) k=j; if(k!=i) { t=x[i]; x[i]=x[k]; x[k]=t;} } }

//形参是指针 #include <stdio.h> int main() { void sort(int x[],int n); //sort函数声明 int i,*p,a[10]; p=a;     //指针变量p指向a[0] printf("please enter 10 integer numbers:"); for(i=0;i<10;i++) scanf("%d",p++); //输入10个整数 p=a; //指针变量p重新指向a[0] sort(p,10);   //调用sort函数 for(p=a,i=0;i<10;i++) { printf("%d ",*p); //输出排序后的10个数组元素 p++; } printf("\n"); return 0; }   void sort(int *x,int n) //形参x是指针变量 { int i,j,k,t; for(i=0;i<n-1;i++) { k=i; for(j=i+1;j<n;j++) if(*(x+j)>*(x+k)) k=j; //*(x+j)就是x[j]，其他亦然 if(k!=i) { t=*(x+i); *(x+i)=*(x+k); *(x+k)=t;} } }

 

8.3.5 通过指针引用多维数组

注：这章节了解即可，如果想提升自己，不仅需要理解还需要会使用。

理解以下这张图便可了解多维数组：

 

 

说明：我们在这里说明一下，在计算机底层是不存在二维数组这种存储方式的，都是以一维数组为基础逻辑化出二维数组，而一维数组不仅是逻辑化更是物理上也是可以实现的。总的来说，二维数组是一维数组的逻辑化，本质上二维数组还是一维数组。只是为了方便人们理解，才把二维数组分为行和列的方式显示。

 

如果用一个指针变量pt来指向此一维数组：

int (*pt)[4];

//表示pt指向由4个整型元素组成的一维数组，此时指针变量pt的基类型是由4个整型元素组成的一维数组

 

例：输出二维数组的有关数据(地址和元素的值)。

#include <stdio.h>

int main()

{ int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};

printf("%d,%d\n",a,*a);    //0行起始地址和0行0列元素地址

printf("%d,%d\n",a[0],*(a+0));   //0行0列元素地址

printf("%d,%d\n",&a[0],&a[0][0]);  //0行起始地址和0行0列元素地址

printf("%d,%d\n",a[1],a+1);   //1行0列元素地址和1行起始地址

printf("%d,%d\n",&a[1][0],*(a+1)+0); //1行0列元素地址

printf("%d,%d\n",a[2],*(a+2));   //2行0列元素地址

printf("%d,%d\n",&a[2],a+2);   //2行起始地址

printf("%d,%d\n",a[1][0],*(*(a+1)+0)); //1行0列元素的值

printf("%d,%d\n",*a[2],*(*(a+2)+0)); //2行0列元素的值

return 0;

}

结果如下：

 

 

说明：要注意看懂以上的格式，区分各种形式的联系和区别。如a和*a在输出上是等价的

 

例：有一个3×4的二维数组，要求用指向元素的指针变量输出二维数组各元素的值。

#include <stdio.h>

int main()

{ int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};

int *p;       //p是int *型指针变量

for(p=a[0];p<a[0]+12;p++)   //使p依次指向下一个元素

{ if((p-a[0])%4==0) printf("\n"); //p移动4次后换行

              printf("%4d",*p);                           //输出p指向的元素的值

}

printf("\n");

return 0;

}

运行结果：

 

例：输出二维数组任一行任一列元素的值。

 

#include <stdio.h>

int main()

{ int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};  //定义二维数组a并初始化

int (*p)[4],i,j;   //指针变量p指向包含4个整型元素的一维数组

p=a;     //p指向二维数组的0行

printf("please enter row and colum:");

scanf("%d,%d",&i,&j); //输入要求输出的元素的行列号

printf("a[%d,%d]=%d\n",i,j,*(*(p+i)+j));   //输出a[i][j]的值

return 0;

}

 

#include <stdio.h>

int main()

{ int a[4]={1,3,5,7};  //定义一维数组a，包含4个元素

int (*p)[4];   //定义指向包含4个元素的一维数组的指针变量中

p=&a;    //使p指向一维数组

printf("%d\n",(*p)[3]); //输出a[3]，输出整数7

return 0;

}

 

比较:

① int a[4];（a有4个元素，每个元素为整型）

② int (*p)[4];

第②种形式表示(*p)有4个元素，每个元素为整型。也就是p所指的对象是有4个整型元素的数组，即p是指向一维数组的指针，见图8.24。应该记住，此时p只能指向一个包含4个元素的一维数组，不能指向一维数组中的某一元素。p的值是该一维数组的起始地址。虽然这个地址（指纯地址）与该一维数组首元素的地址相同，但它们的基类型是不同的。

 

指向由m个元素组成的一维数组的指针变量

要注意指针变量的类型，从“int (*p)[4];”可以看到，p的类型不是int *型，而是int (*)[4]型，p被定义为指向一维整型数组的指针变量，一维数组有4个元素，因此p的基类型是一维数组，其长度是16字节。“*(p+2)+3”括号中的2是以p的基类型(一维整型数组)的长度为单位的，即p每加1，地址就增加16个字节（4个元素，每个元素4个字节），而“*(p+2)+3”括号外的数字3，不是以p的基类型的长度为单位的。由于经过*(p+2)的运算，得到a[2]，即&a[2][0]，它已经转化为指向列元素的指针了，因此加3是以元素的长度为单位的，加3就是加(3×4)个字节。虽然p+2和*(p+2)具有相同的值，但由于它们所指向的对象的长度不同，因此(p+2)+3和*(p+2)+3的值就不相同了。

一维数组名可以作为函数参数，多维数组名也可作函数参数。

用指针变量作形参，以接受实参数组名传递来的地址。可以有两种方法:

① 用指向变量的指针变量；

② 用指向一维数组的指针变量。

例8：有一个班，3个学生，各学4门课，计算总平均分数以及第n个学生的成绩。

#include <stdio.h>

int main()

{ void average(float *p,int n);

void search(float (*p)[4],int n);

float score[3][4]={{65,67,70,60},{80,87,90,81},{90,99,100,98}};

average(*score,12);  //求12个分数的平均分

search(score,2);   //求序号为2的学生的成绩

return 0;

}

 

void average(float *p,int n)  //定义求平均成绩的函数

{ float *p_end;

float sum=0,aver;

p_end=p+n-1;

//n的值为12时，p_end的值是p+11，指向最后一个元素

for(;p<=p_end;p++)

sum=sum+(*p);

aver=sum/n;

printf("average=%5.2f\n",aver);

}

 

void search(float (*p)[4],int n)

//p是指向具有4个元素的一维数组的指针

{ int i;

printf("The score of No.%d are:\n",n);

for(i=0;i<4;i++)

              printf("%5.2f ",*(*(p+n)+i));

printf("\n");

}

运行结果：

 

 

注：实参与形参如果是指针类型，应当注意它们的基类型必须一致。不应把int *型的指针(即数组元素的地址)传给int (*)[4] 型(指向一维数组)的指针变量，反之亦然。

例：在上例的基础上，查找有一门以上课程不及格的学生，输出他们的全部课程的成绩。

#include <stdio.h>

int main()

{ void search(float (*p)[4],int n); //函数声明

float score[3][4]={{65,57,70,60},{58,87,90,81},{90,99,100,98}};

//定义二维数组函数score

search(score,3);    //调用search函数

return 0;

}

 

void search(float (*p)[4],int n)

//形参p是指向包含4个float型元素的一维数组的指针变量

{ int i,j,flag;

for(j=0;j<n;j++)

{ flag=0;

for(i=0;i<4;i++)

if(*(*(p+j)+i)<60) flag=1;

//*(*(p+j)+i)就是score[j][i]

if(flag==1)

{ printf("No.%d fails,his scores are:\n",j+1);

for(i=0;i<4;i++)

printf("%5.1f ",*(*(p+j)+i));

//输出*(*(p+j)+i)就是输出score[j][i]的值

printf("\n");

}

}

}

运行结果：

 

 

 

8.4 通过指针引用字符串

8.4.1 字符串的引用方式

(1)用字符数组存放一个字符串，可以通过数组名和下标引用字符串中一个字符，也可以通过数组名和格式声明“%s”输出该字符串。

(2)用字符指针变量指向一个字符串常量，通过字符指针变量引用字符串常量。

 

例：定义一个字符数组，在其中存放字符串″I love China!″，输出该字符串和第8个字符。

#include <stdio.h>

int main()

{ char string[]="I love China!"; //定义字符数组sting

printf("%s\n",string);  //用%s格式声明输出string，可以输出整个字符串

       printf("%c\n",string[7]);         //用%c格式输出一个字符数组元素

return 0;

}

运行结果：

 

 

例：通过字符指针变量输出一个字符串。

#include <stdio.h>

int main()

{ char *string="I love China!"; //定义字符指针变量string并初始化

printf("%s\n",string);  //输出字符串

return 0;

}

运行结果：

 

 

在C语言中只有字符变量，没有字符串变量。

char *string="I love China!";

等价于

char *string;  //定义一个char *型变量

string=″I love China!″;

//把字符串第1个元素的地址赋给字符指针变量string

注：string被定义为一个指针变量，基类型为字符型。它只能指向一个字符类型数据，而不能同时指向多个字符数据，更不是把″I love China!″这些字符存放到string中（指针变量只能存放地址），也不是把字符串赋给*string。只是把″I love China!″的第1个字符的地址赋给指针变量string。

 

可以对指针变量进行再赋值，string=″I am a student.″;  //对指针变量string重新赋值

可以通过字符指针变量输出它所指向的字符串，printf(″%s\n″,string); //%s可对字符串进行整体的输入输出

 

说明：%s是输出字符串时所用的格式符，在输出项中给出字符指针变量名string，则系统会输出string所指向的字符串第1个字符，然后自动使string加1，使之指向下一个字符，再输出该字符……如此直到遇到字符串结束标志′\0′为止。注意，在内存中，字符串的最后被自动加了一个′\0′。

 

例：将字符串a复制为字符串b，然后输出字符串b。

//用数组的方式输出

#include <stdio.h>

int main()

{ char a[]="I am a student.",b[20]; //定义字符数组

int i;

for(i=0;*(a+i)!='\0';i++)

*(b+i)=*(a+i);  //将a[i]的值赋给b[i]

*(b+i)='\0';    //在b数组的有效字符之后加'\0'

printf("string a is:%s\n",a);//输出a数组中全部有效字符

printf("string b is:");

for(i=0;b[i]!='\0';i++)

printf("%c",b[i]); //逐个输出b数组中全部有效字符

printf("\n");

return 0;

}

 

//用指针变量

#include <stdio.h>

int main()

{ char a[]="I am a boy.",b[20],*p1,*p2;

p1=a;p2=b;

//p1,p2分别指向a数组和b数组中的第一个元素

for(;*p1!='\0';p1++,p2++)  //p1,p2每次自加1

*p2=*p1;

//将p1所指向的元素的值赋给p2所指向的元素

*p2='\0';   //在复制完全部有效字符后加'\0'

printf("string a is:%s\n",a); //输出a数组中的字符

printf("string b is:%s\n",b); //输出b数组中的字符

return 0;

}

 

8.4.2 字符指针作函数参数

例：用函数调用实现字符串的复制

(1) 用字符数组名作为函数参数

#include <stdio.h>

int main()

{ void copy_string(char from[], char to[]);

char a[]="I am a teacher.";

char b[]="You are a student.";

printf("string a=%s\nstring b=%s\n",a,b);

printf("copy string a to string b:\n");

copy_string(a,b);  //用字符数组名作为函数实参

printf("\nstring a=%s\nstring b=%s\n",a,b);

return 0;

}

 

void copy_string(char from[], char to[])    //形参为字符数组

{ int i=0;

while(from[i]!='\0')

{ to[i]=from[i]; i++;}

to[i]='\0';

}

运行结果：

 

 

(2) 用字符型指针变量作实参

#include <stdio.h>

int main()

{ void copy_string(char from[], char to[]); //函数声明

char a[]="I am a teacher.";  //定义字符数组a并初始化

char b[]="You are a student."; //定义字符数组b并初始化

       char *from=a,*to=b; //from指向a数组首元素，to指向b数组首元素

printf("string a=%s\nstring b=%s\n",a,b);

printf("copy string a to string b:\n");

copy_string(from,to); //实参为字符指针变量

printf("\nstring a=%s\nstring b=%s\n",a,b);

return 0;

}

void copy_string(char from[], char to[])   //形参为字符数组

{ int i=0;

while(from[i]!='\0')

{ to[i]=from[i]; i++;}

to[i]='\0';

}

运行结果：

 

 

说明：指针变量from的值是a数组首元素的地址，指针变量to的值是b数组首元素的地址。它们作为实参，把a数组首元素的地址和b数组首元素的地址传递给形参数组名from和to(它们实质上也是指针变量)。其他与程序(1)相同。

(3) 用字符指针变量作形参和实参

#include <stdio.h>

int main()

{ void copy_string(char *from, char *to);

char *a="I am a teacher.";  //a是char*型指针变量

char b[]="You are a student."; //b是字符数组

char *p=b;  //使指针变量p指向b数组首元素

printf("string a=%s\nstring b=%s\n",a,b); //输出a串和b串

printf("copy string a to string b:\n");

copy_string(a,p); //调用copy_string函数，实参为指针变量

printf("\nstring a=%s\nstring b=%s\n",a,b); //输出改变后的a串和b串

return 0;

}

 

void copy_string(char *from, char *to) //定义函数，形参为字符指针变量

{ for(;*from!='\0';from++,to++)

{ *to=*from;}

*to='\0';

}

运行结果：

 

 

函数void copy_string(char *from, char *to)还有以下等价几种，只需记住一种即可，其它做了解。最好的情况当然是全都会用。

void copy_string(char *from, char *to) { for(;(*to++=* from++)!='\0';); //或for(;*to++=* from++;); }	void copy_string(char *from, char *to) { while((*to=*from)!='\0') //或while(*to=*from) { to++; from++;} }	void copy_string(char *from, char *to) { while(*from!='\0') //或while(*from) ，因为'\0'的ASCII码为0 *to++=*from++; *to='\0'; }
void copy_string(char *from, char *to) { while((*to++=*from++)!='\0'); //或while(*to++=*from++) }	void copy_string（char from[]，char to[]） { char *p1, *p2; p1=from;p2=to; while((*p2++=*p1++)!='\0'); }

字符指针作为函数参数时，实参与形参的类型有以下几种对应关系：

 

 

8.4.3 使用字符指针变量和字符数组的比较

 

 

例：改变指针变量的值。

#include <stdio.h>

int main()

{ char *a="I love China!";

a=a+7;   //改变指针变量的值，即改变指针变量的指向

printf("%s\n",a); //输出从a指向的字符开始的字符串

return 0;

}

运行结果：

 

 

 

#include <stdio.h>

int main()

{ char str[]={"I love China!"};

str=str+7;

printf("%s\n",str);

return 0;

}

说明：

(1)指针变量的值是可以改变的，而字符数组名代表一个固定的值(数组首元素的地址)，不能改变。

(2)指针变量a的值是可以变化的。printf函数输出字符串时，从指针变量a当时所指向的元素开始，逐个输出各个字符，直到遇'\0'为止。而数组名虽然代表地址，但它是常量，它的值是不能改变的。

8.5 指向函数的指针

8.5.1 什么是函数指针

如果在程序中定义了一个函数，在编译时会把函数的源代码转换为可执行代码并分配一段存储空间。这段内存空间有一个起始地址，也称为函数的入口地址。每次调用函数时都从该地址入口开始执行此段函数代码。

函数名就是函数的指针，它代表函数的起始地址。

可以定义一个指向函数的指针变量，用来存放某一函数的起始地址，这就意味着此指针变量指向该函数。例如: int (*p)(int,int);

定义p是一个指向函数的指针变量，它可以指向函数类型为整型且有两个整型参数的函数。此时，指针变量p的类型用int (*)(int,int)表示。

8.5.2 用函数指针变量调用函数

例：用函数求整数a和b中的大者

//(1)通过函数名调用函数

#include <stdio.h>

int main()

{ int max(int,int); //函数声明

int a,b,c;

printf("please enter a and b:");

scanf("%d,%d",&a,&b);

c=max(a,b);  //通过函数名调用max函数

printf("a=%d\nb=%d\nmax=%d\n",a,b,c);

return 0;

}

 

int max(int x,int y)  //定义max函数

{ int z;

if(x>y) z=x;

else z=y;

return(z);

}

 

(2) 通过指针变量调用它所指向的函数

#include <stdio.h>

int main()

{ int max(int,int); //函数声明

int (*p)(int,int); //定义指向函数的指针变量p

int a,b,c;

p=max;   //使p指向max函数

printf("please enter a and b:");

scanf("%d,%d",&a,&b);

c=(*p)(a,b);  //通过指针变量调用max函数

printf("a=%d\nb=%d\nmax=%d\n",a,b,c);

return 0;

}

int max(int x,int y)  //定义max函数

{ int z;

if(x>y)z=x;

else z=y;

return(z);

}

运行结果：

 

 

8.5.3 怎样定义和使用指向函数的指针变量

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

类型名 (*指针变量名)(函数参数表列)

如：

int (*p)(int,int);

说明：

(1) 定义指向函数的指针变量，并不意味着这个指针变量可以指向任何函数，它只能指向在定义时指定的类型的函数。

(2)  如果要用指针调用函数，必须先使指针变量指向该函数。

(3) 在给函数指针变量赋值时，只须给出函数名而不必给出参数。

(4) 用函数指针变量调用函数时，只须将(*p)代替函数名即可（p为指针变量名），在(*p)之后的括号中根据需要写上实参。

(5) 对指向函数的指针变量不能进行算术运算，如p+n,p++,p--等运算是无意义的。

(6) 用函数名调用函数，只能调用所指定的一个函数，而通过指针变量调用函数比较灵活，可以根据不同情况先后调用不同的函数。

例：输入两个整数，然后让用户选择1或2，选1时调用max函数，输出二者中的大数，选2时调用min函数，输出二者中的小数。

#include <stdio.h>

int main()

{ int max(int,int); //函数声明

int min(int x,int y); //函数声明

int (*p)(int,int); //定义指向函数的指针变量

int a,b,c,n;

printf("please enter a and b:");

scanf("%d,%d",&a,&b);

printf("please choose 1 or 2:");

scanf("%d",&n); //输入1戓2

if(n==1) p=max; //如输入1，使p指向max函数

else if (n==2) p=min; //如输入2，使p指向min函数

c=(*p)(a,b);  //调用p指向的函数

printf("a=%d,b=%d\n",a,b);

if(n==1) printf("max=%d\n",c);

else printf("min=%d\n",c);

return 0;

}

 

int max(int x,int y)

{ int z;

if(x>y) z=x;

else z=y;

return(z);

}

 

int min(int x,int y)

{ int z;

if(x<y) z=x;

else z=y;

return(z);

}

运行结果：

 

OR

 

8.5.4 用指向函数的指针作函数参数

 

 

例：有两个整数a和b，由用户输入1,2或3。如输入1，程序就给出a和b中的大者，输入2，就给出a和b中的小者，输入3，则求a与b之和。

#include <stdio.h>

int main()

{ int fun(int x,int y, int (*p)(int,int)); //fun函数声明

       int max(int,int);                //max函数声明

int min(int,int);   //min函数声明

int add(int,int);   //add函数声明

int a=34,b=-21,n;

printf("please choose 1,2 or 3:");

scanf("%d",&n);   //输入1,2或3之一

if(n==1) fun(a,b,max);  //输入1时调用max函数

else if(n==2) fun(a,b,min); //输入2时调用min函数

else if(n==3) fun(a,b,add); //输入3时调用add函数

return 0;

}

 

int fun(int x,int y,int (*p)(int,int)) //定义fun函数

{      int result;

result=(*p)(x,y);

       printf("%d\n",result);             //输出结果

}

 

 

int max(int x,int y) //定义max函数

{ int z;

if(x>y) z=x;

else z=y;

printf("max=" );

       return(z);            //返回值是两数中的大者

}

 

int min(int x,int y) //定义min函数

{ int z;

if(x<y) z=x;

else z=y;

printf("min=");

return(z);  //返回值是两数中的小者

}

 

int add(int x,int y) //定义add函数

{ int z;

z=x+y;

printf("sum=");

return(z);  //返回值是两数之和

}

运行结果：不同选择有不同的答案

 

 

 

 

 

 

 

 

8.6 返回指针值的函数

定义返回指针值的函数的一般形式为：

类型名 *函数名(参数表列);

解释：

一个函数可以返回一个整型值、字符值、实型值等，也可以返回指针型的数据，即地址。其概念与以前类似，只是返回的值的类型是指针类型而已。如：

int *a(int x,int y);

a是函数名，调用它以后能得到一个int*型(指向整型数据)的指针，即整型数据的地址。x和y是函数a的形参，为整型。

注：在“*a”两侧没有括号，在a的两侧分别为*运算符和()运算符。而()优先级高于*，因此a先与()结合，显然这是函数形式。这个函数前面有一个*，表示此函数是指针型函数（函数值是指针）。最前面的int表示返回的指针指向整型变量。

例：有a个学生，每个学生有b门课程的成绩。要求在用户输入学生序号以后，能输出该学生的全部成绩。用指针函数来实现。

#include <stdio.h>

int main()

{ float score[][4]={{60,70,80,90},{56,89,67,88},{34,78,90,66}};

//定义数组，存放成绩

float *search(float (*pointer)[4],int n); //函数声明

float *p;

int i,k;

printf("enter the number of student:");

scanf("%d",&k); //输入要找的学生的序号

printf("The scores of No.%d are:\n",k);

p=search(score,k); //调用search函数，返回score[k][0]的地址

for(i=0;i<4;i++)

printf("%5.2f\t",*(p+i)); //输出score[k][0]~score[k][3]的值

printf("\n");

return 0;

}

 

float *search(float (*pointer)[4],int n)

//形参pointer是指向一维数组的指针变量

{ float *pt;

pt=*(pointer+n); //pt的值是&score[k][0]

return(pt);

}

运行结果：

 

 

例：对上例题，找出其中有不及格的课程的学生及其学生号。

#include <stdio.h>

int main()

{ float score[][4]={{60,70,80,90},{56,89,67,88},{34,78,90,66}};

//定义数组，存放成绩

float *search(float (*pointer)[4]); //函数声明

float *p;

int i,j;

for(i=0;i<3;i++)    //循环3次

{ p=search(score+i);

//调用search函数,如有不及格返回score[i][0]的地址,否则返回NULL

if(p==*(score+i))

//如果返回的是score[i][0]的地址，表示p的值不是NULL

{ printf("No.%d score:",i);

for(j=0;j<4;j++)

printf("%5.2f  ",*(p+j));

//输出score[i][0]~score[i][3]的值

printf("\n");

              }

}

       return 0;

}

 

float *search(float (*pointer)[4])

//定义函数，形参pointer是指向一维数组的指针变量

{ int i=0;

float *pt;

pt=NULL; //先使pt的值为NULL

for(;i<4;i++)

if(*(*pointer+i)<60) pt=*pointer;

              //如果有不及格课程，使pt指向score[i][0]

return(pt);

}

运行结果：

 

8.7 指针数组和多重指针

8.7.1 什么是指针数组

定义一维指针数组的一般形式为

类型名 *数组名[数组长度];

如：

int *p[4];

一个数组，若其元素均为指针类型数据，称为指针数组，也就是说，指针数组中的每一个元素都存放一个地址，相当于一个指针变量。

指针数组比较适合用来指向若干个字符串，使字符串处理更加方便灵活。

 

例：将若干字符串按字母顺序（由小到大）输出。

 

 

 

#include <stdio.h>

#include <string.h>

int main()

{ void sort(char *name[],int n);  //函数声明

void print(char *name[],int n); //函数声明

char *name[]={"Follow me","BASIC",

       "Great Wall","FORTRAN","Computer design"};

//定义指针数组，它的元素分别指向5个字符串

int n=5;

       sort(name,n);     //调用sort函数，对字符串排序

print(name,n); //调用print函数，输出字符串

return 0;

}

 

void sort(char *name[],int n)   //定义sort函数

{ char *temp;

int i,j,k;

for(i=0;i<n-1;i++)   //用选择法排序

{ k=i;

for(j=i+1;j<n;j++)

if(strcmp(name[k],name[j])>0) k=j;

if(k!=i)

{ temp=name[i]; name[i]=name[k]; name[k]=temp;}

}

}

 

void print(char *name[],int n) //定义print函数

{ int i;

for(i=0;i<n;i++)

printf("%s\n",name[i]);

//按指针数组元素的顺序输出它们所指向的字符串

}

运行结果：

 

 

在了解了指针数组的基础上，需要了解指向指针数据的指针变量，简称为指向指针的指针。

 

 

例：使用指向指针数据的指针变量。

#include <stdio.h>

int main()

{ char *name[]={"Follow me","BASIC","Great Wall","FORTRAN","Computer design"};

char **p;

int i;

for(i=0;i<5;i++)

{ p=name+i;

printf("%s\n",*p);

}

return 0;

}

运行结果：

 

 

说明：

(1) p是指向char*型数据的指针变量，即指向指针的指针。在第1次执行for循环体时，赋值语句“p=name+i;”使p指向name数组的0号元素name［0］，*p是name［0］的值，即第1个字符串首字符的地址，用printf函数输出第1个字符串（格式符为%s）。执行5次循环体，依次输出5个字符串。

 

(2) 指针数组的元素也可以不指向字符串，而指向整型数据或实型数据等。

 

例：有一个指针数组，其元素分别指向一个整型数组的元素，用指向指针数据的指针变量，输出整型数组各元素的值。

#include <stdio.h>

int main()

{ int a[5]={1,3,5,7,9};

int *num[5]={&a[0],&a[1],&a[2],&a[3],&a[4]};

int **p,i;    //p是指向指针型数据的指针变量

p=num;    //使p指向num[0]

for(i=0;i<5;i++)

{ printf("%d ",**p);

p++;

}

printf("\n");

return 0;

}

运行结果：

 

8.7.3 指针数组作main函数的形参

 

 

 

 

int main(int argc,char *argv[]) { while(argc>1) { ++argv; printf("%s\n", *argv); --argc; } return 0; }

int main(int argc,char *argv[]) { while(argc-->1) printf("%s\n", *++argv); return 0; }.

 

 

 

 

8.8 动态内存分配与指向它的指针变量

8.8.1 什么是内存的动态分配

 

 

8.8.2 怎样建立内存的动态分配

1. 用malloc函数开辟动态存储区

函数原型为

void *malloc(unsigned int size);

作用：在内存的动态存储区中分配一个长度为size的连续空间。形参size的类型定为无符号整型(不允许为负数)。此函数的值（即“返回值”）是所分配区域的第一个字节的地址，或者说，此函数是一个指针型函数，返回的指针指向该分配域的第一个字节。如：

malloc(100);              //开辟100字节的临时分配域，函数值为其第1个字节的地址

指针的基类型为void，即不指向任何类型的数据，只提供一个纯地址。如果此函数未能成功地执行(例如内存空间不足)，则返回空指针(NULL)。

 

2.用calloc函数开辟动态存储区

函数原型为

void *calloc(unsigned n, unsigned size);

作用：在内存的动态存储区中分配n个长度为size的连续空间，这个空间一般比较大，足以保存一个数组。

p=calloc(50,4);  //开辟50×4个字节的临时分配域，把首地址赋给指针变量p

用calloc函数可以为一维数组开辟动态存储空间，n为数组元素个数，每个元素长度为size。这就是动态数组。函数返回指向所分配域的第一个字节的指针；如果分配不成功，返回NULL。

 

3.用realloc函数重新分配动态存储区

函数原型为

void *realloc(void *p,unsigned int size);

作用：如果已经通过malloc函数或calloc函数获得了动态空间，想改变其大小，可以用realloc函数重新分配。

realloc(p,50); //将p所指向的已分配的动态空间改为50字节

 

用realloc函数将p所指向的动态空间的大小改变为size。p的值不变。如果重分配不成功，返回NULL。

 

4.用free函数释放动态存储区

函数原型为

void free(void *p);

作用：释放指针变量p所指向的动态空间，使这部分空间能重新被其他变量使用。p应是最近一次调用calloc或malloc函数时得到的函数返回值。

free(p);  //释放指针变量p所指向的已分配的动态空间

free函数无返回值。

 

说明：以上4个函数的声明在stdlib.h头文件中，在用到这些函数时应当用“#include <stdlib.h>”指令把stdlib.h头文件包含到程序文件中。

 

8.8.3 void指针类型

C 99允许使用基类型为void的指针类型。可以定义一个基类型为void的指针变量(即void*型变量)，它不指向任何类型的数据。在将它的值赋给另一指针变量时由系统对它进行类型转换，使之适合于被赋值的变量的类型。

int *pt;

pt=(int *)mcaloc(100); //mcaloc(100)是void *型，把它转换为int *型

注：不要把“指向void类型”理解为能指向“任何的类型”的数据，而应理解为“指向空类型”或“不指向确定的类型”的数据。

例：建立动态数组，输入5个学生的成绩，另外用一个函放数检查其中有无低于60分的，输出不合格的成绩。

#include <stdio.h>

#include <stdlib.h>    //程序中用了malloc函数，应包含stdlib.h

int main()

{ void check(int *);    //函数声明

int *p1,i;      //p1是int型指针

p1=(int *)malloc(5*sizeof(int)); //开辟动态内存区，将地址转换成int *型，然后放在p1中

       for(i=0;i<5;i++)

              scanf("%d",p1+i);                   //输入5个学生的成绩

check(p1);     //调用check函数

return 0;

}

 

void check(int *p)     //定义check函数，形参是int*指针

{ int i;

printf("They are fail:");

for(i=0;i<5;i++)

              if(p[i]<60) printf("%d ",p[i]);        //输出不合格的成绩

printf("\n");

}

运行结果：

 

 

有关指针的小结