【文档说明】C语言程序设计教程第8章课件1.ppt，共(77)页，795.512 KB，由小橙橙上传

转载请保留链接：https://www.ichengzhen.cn/view-44521.html

以下为本文档部分文字说明：

第8章指针第八章指针•本章要求–理解指针的概念；–掌握指针变量的定义和使用方法；–掌握指针变量作函数参数时，数据的传递方式；–掌握使用指针处理一维、二维数组的方法；–掌握使用指针处理字符串的方法。•本章重点–指针变量的定义和使

用–指针变量作函数参数–使用指针处理一维数组和字符串•本章难点–使用指针处理一维、二维数组8.1指针与指针变量8.2指针与函数8.3指针与数组8.4指针与字符串8.5指针数组与命令行参数8.6程序举例第8章指针第8章指针8.1指针与指针变量8.1.1指

针的概念1.内存与变量地址内存地址：内存是计算机用于存储数据的存储器，以一个字节作为存储单元，为了便于访问，给每个字节单元一个唯一的编号，第一字节单元编号为0，以后各单元按顺序连续编号，这些单元编号称为内存单元的地址。变量地址：变量所分配存储空间的首字节单元地址（字节单元编

号）。第8章指针2.变量的三要素：名字、类型与值每个变量都通过变量名与相应的存储单元相连系，具体分配哪些单元给变量，由Ｃ编译系统完成变量名到对应内存单元地址的变换。变量分配存储空间的大小由类型决定。变量的值则是指相应存储单元的内容。3.内存存取方式直接

存取：把直接按变量名或地址存取变量值的方式称为“直接存取”方式。间接存取：通过定义一种特殊的变量专门存放内存或变量的地址，然后根据该地址值再去访问相应的存储单元。第8章指针将要访问变量a的地址存放在另

一个变量p中，当需要访问变量a时，先取出变量p的内容即变量a的地址，再根据此地址找到变量a所对应的存储空间。这种间接的通过变量p得到变量a的地址，再存取变量a的值的方式即为“间接存取”。能够存放其它变量地址的变量称作指针变

量通常称变量p指向变量a，变量a是变量p所指向的对象…400012345400040024800pap(4800)p(4800)a(4000)4000123454000间接存取示意图第8章指针4、指针的概念在Ｃ语言中，用指针来表示一个变量指向另一个变量这样的指向关系。指针和指针变量指针：是一个变

量的地址指针变量：用来存储变量地址(指针)的变量如：p即是一个指针变量,它存放的是a的地址4000。第8章指针8.1.2指针变量的定义与初始化1.指针变量的定义类型标识符*指针变量名；例：float*p

1;(定义p1为指向实型变量的指针变量)char*p2;(定义p2为指向字符型变量的指针变量)在指针变量定义中，*是一个说明符，它表明其后的变量是指针变量，如p是指针变量,而不要认为“*p”是指针变量。指针变量

定义时指定的数据类型不是指针变量本身（变量存放的值）的数据类型，而是指针变量所指向的对象（或称目标）的数据类型指针变量存放的是所指向的某个变量的地址值，而普通变量保存的是该变量本身的值指针变量并不固定指向一个变量，可指向同类型的不

同变量第8章指针2.指针运算符与地址运算符与指针引用有关的两个运算符：&与*。&:取地址运算符*：指针运算符，或称指向运算符、间接访问运算符。指针指向的对象的表示形式:*指针变量此处*是访问指针所指对象的运算符,与指针定义时的*不同。第8章指针3.指针变量初始化若有定义：inta,*p

;语句仅仅定义了指针变量p，但指针变量并未指向确定的变量(或内存单元)。因为这些指针变量还没有赋给确定的地址值，只有将某一具体变量的地址赋给指针变量之后，指针变量才指向确定的变量（内存单元）。指针变量初始化:在定义指针时同时给指针一个初始值如：inta,*p=&

a;40003a(4000)p*p第8章指针4.指针变量的引用①*指针变量名——代表所指变量的值。②指针变量名——代表所指变量的地址。有定义：inta,*p=&a;用*p来表示p指向的对象a,*p与a是等价的。*p可以象普通变量一样使用。例如：a=

12;*p=12;scanf("%d",&*p);scanf("%d",p);printf(“%d%d”,*p,a);注意：*与&具有相同的优先级，结合方向从右到左。这样，&*p即&(*p),是对变量*p取地址，它与&a等价；p与&(*p)等价，a与*(&a)等价。第8章指针8.1.3指针

运算1.指针的赋值运算（1）将变量地址值赋给指针变量，使指针指向该变量。设有如下定义：inta,b,*pa,*pb;float*pf;第一行定义了整型变量a,b及指针变量pa,pb。pa、pb还没有被赋值，因此pa、pb没有指向任何变量,下面语句完成对p

a,pb的赋值：pa=&a;pb=&b;第8章指针例如：intj,k;int*pointer1,*pointer2;pointer1=&j;pointer2=&k;pointer1jpointer2k第8章指针

(2)相同类型的指针变量间的赋值pa与pb都是整型指针变量，它们间可以相互赋值，如：pb=pa;即pa,pb都指向变量a，此时a、*pa、*pb是等价的。指针指向变化如下图:注意：只有相同类型的指针变量才能相互赋值

，如pf=pa;是不允许的。因为pa是整型指针,pf是浮点型指针。&a&bpapba,*pab,*pb&a&apapba,*pa,*pbb第8章指针（３）给指针变量赋空值给指针变量赋空值，说明该指针不指向任何变量。“空”指针值用

NULL表示，NULL是在头文件stdio.h中预定义的常量，其值为０，在使用时应加上预定义行,如：#include"stdio.h"int*pa=NULL;亦可以用下面的语句给指针赋“空值”:pa=0;或:pa=‟\0‟;这里指针pa并非指向0地址单元，而是具有一个确定的“空值”，表示pa

不指向任何变量。注意：指针虽然可以赋值0，但却不能把其它的常量地址赋给指针。例如：pa=4000;是非法的。第8章指针例8.1指针定义与初始化main(){inta,b;int*pointer_1,*pointer_2;a=100;b=10;pointer_1=&a;po

inter_2=&b;printf("%d,%d\n",a,b);printf("%d,%d\n",*pointer_1,*pointer_2);}第8章指针程序运行结果：100，10100，10&a&bbp

ointer_1pointer_2a*pointer_1*pointer_2第8章指针例8.2从键盘上输入两个整数到a、b,按由大到小输出。#include<stdio.h>main()｛inta,b,*pa=&a,*pb=&b,*p;/*定义指针变量pa、pb,如下页图a*

/scanf(″%d%d″,&a,&b);if(*pa＜*pb){p=pa;/*进行指针交换,如下页图b,c*/pa=pb;pb=p；}printf(″\na=%d,b=%d\n″,a,b);printf(″\n

max=%d,min=%d″,*pa,*pb);/*pa指向大数，pb指向小数*/}第8章指针若输入：1222↙输出结果:a=12,b=22max=22,min=12(a)(b)(c)指针变化示意图1222ppapb1222ppapbpapbababab第8章指针2.指针的算术运算(1)加减运算

:一个指针可以加、减一个整数n，其结果与指针所指对象的数据类型有关。指针变量的值应增加或减少‚n×sizeof(指针类型)”。加减运算常用于数组的处理。对指向一般数据的指针，加减运算无实际意义。例如：inta[10]，*p=a，*x；x=p+3；/*实

际上是p加上3*2个字节赋给x，x指向数组的第三个分量*/对于不同基类型的指针，指针变量‚加上‛或‚减去‛一个整数n所移动的字节数是不同的。例如：floata[10]，*p=a，*x；p=p+3；/*实际上是p加上3*4个字节赋给x，x

依然指向数组的第三个分量*/第8章指针(2)自增自减运算指针变量自增、自减运算具有上述运算的特点，但有前置后置、先用后用的考虑，务请小心。例如：inta[10]，*p=a，*x；x=p++；/*x第一个元素分量，p指向第二个元素*/x=++p；/*x、p均指向

数组的第二个分量*/*p++相当于*（p++）。*（p++）与（*p）++含义不同，前者表示地址自增，后者表示当前所指向的数据自增。第8章指针2.*&a的含意是什么?(答：a)3.(*p)++相当于什么?(答：a+

+)思考：1.若有定义inta,*p;执行了“p=&a”,则：“&*p”的含意是什么？(答：相当于&a)第8章指针3.指针的关系运算与基本类型变量一样，指针可以进行关系运算。在关系表达式中允许对两个指针进行所有的关系运算。若p,q是两个同类型的指针变量，则：p＞q,p<q,p==q,p

!=q，p>=q都是允许的。指针的关系运算在指向数组的指针中广泛的运用，假设p、q是指向同一数组的两个指针，执行p＞q的运算，其含义为，若表达式结果为真（非０值），则说明p所指元素在q所指元素之后。或者说q所指元素离数组第一个元素更近些。注意：

在指针进行关系运算之前，指针必须指向确定的变量或存储区域，即指针有初始值；另外，只有相同类型的指针才能进行比较。第8章指针8.1.4多级指针把指向指针型数据的指针变量称为指向指针的指针，或称多级指针。二级指针的定义形式如下：数据类型**指针变量例如：inta,*p,**pp;a=

22;p=&a;pp=&p;假设变量a的地址为4000，指针p的地址为4100，二级指针pp的地址为4800。a、p、pp三者的关系如上图。&p=4100&a=400022pp(4800)p(4100)a(4000)

第8章指针8.2指针与函数8.2.1指针作为函数参数利用指针作函数参数，可以实现函数之间多个数据的传递，当形参为指针变量时，其对应实参可以是指针变量或存储单元地址。(1)函数形参为指针变量，用指针变量作为实参(2)函数形参为指针变量，用变量地址作为实参例8.3编写一个交换两个变量的函数，在主

程序中调用，实现两个变量值的交换。第8章指针程序如下：#include<stdio.h>main(){inta,b;int*pa,*pb;voidswap(int*p1,int*p2);/*函数声明*/scanf(″%d%d

″,&a,&b);pa=&a;/*pa指向变量a*/pb=&b;/*pb指向变量b*/swap(pa,pb);printf(″\na=%d,b=%d\n″,a,b);｝或：swap(&a,&b);voidswap(int*p1,int*p2)｛inttemp;temp=*p1;*p1=*

p2;*p2=temp;｝程序运行结果如下：输入：1222↙输出：a=22，b=12第8章指针两点说明：(1)若在函数体中交换指针变量的值，实参a、b的值并不改变，指针参数亦是传值。int*p；p=p1；p

1=p2；p2=p；不要希望如此完成处理。(2)函数中交换值时不能使用无初值的指针变量作临时变量。例如：int*p；*p=*p1；*p1=*p2；*p2=*p；p无确定值，对p的使用可能带来不可预期的后果。第8章指针8.2.2指针函数指针函数:是指返回值为指针

的函数指针函数的定义形式：类型标示符*函数名（参数）例如：int*fun(inta,intb)｛函数体语句｝在函数体中有返回指针或地址的语句，形如:return(&变量名);或return(指针变量);并且返回值的类型要与函数类型一致。第8章指针例8.3分析如下程序main(

){inta,b,*p;int*max(intx,inty);scanf(“%d,%d”,&a,&b);p=max(a,b);printf(“max=%d”,*p);}int*max(intx,inty){if

(x>y)return(&x);elsereturn(&y);}第8章指针8.2.3指向函数的指针一个函数包括一组指令序列，存储在某一段内存中，这段内存空间的起始地址称为函数的入口地址称函数入口地址为函数的指针。函数名代表函数的入口地

址可以定义一个指针变量，其值等于该函数的入口地址，指向这个函数，这样通过这个指针变量也能调用这个函数。这种指针变量称为指向函数的指针变量。定义指向函数的指针变量的一般形式为：类型标识符（*指针变量名)()；例如：int(*p)();/*指针变量p

可以指向一个整型函数*/float(*q)();/*指针变量q可以指向一个浮点型函数*/第8章指针刚定义的指向函数的指针变量，亦象其它指针变量一样要赋以地址值才能引用。当将某个函数的入口地址赋给指向函数的指针变量，就可用该指针变量来调用所指向的函数给函数指针赋初值：将函数名（函数的入口地址值）赋

给指针变量例如intm,(*p)();intmax(inta,intb);则可以p=max;/*p指向函数max()*/指针调用函数的一般形式为：(*指针变量)(实参表)；如上例：m=(*p)(12,22

);/*比较m=max(12,22);*/第8章指针注意:用函数指针调用函数是间接调用，没有参数类型说明，C编译系统也无法进行类型检查，因此，在使用这种形式调用函数时要特别小心。实参一定要和指针所指函数的形参类型一致。函数指针可以作为函数参数，此时，当函数指针每次指向不同的函数时，可执行不同

的函数来完成不同的功能例8.4函数max()用来求一维数组的元素的最大值，在主调函数中用函数名调用该函数与用函数指针调用该函数来实现。第8章指针程序如下:#include"stdio.h"#defineM8main(){floatsumf,sump;floata[M]={11,2,-3,4

.5,5,69,7,80};float(*p)();/*定义指向函数的指针p*/floatmax(floata[],intn);/*函数声明*/p=max;/*函数名（函数入口地址）赋给指针p*/sump=(*p)(a,M);/*用指针方式调用函数*/sumf=max(a,M);/*用函

数名调用max()函数*/printf("sump=%.2f\n",sump);printf("sumf=%.2f\n",sumf);}第8章指针程序接上页:floatmax(floata[],intn){intk;floats;s=a[0];for(k=0;k<n;k

++)if(s<a[k])s=a[k];returns;}程序运行结果：sump=80.00sumf=80.00第8章指针指向函数的指针的使用步骤：（1）定义一个指向函数的指针变量，形如：float(*p)

()；（2）为函数指针赋值，格式如下：p=函数名；注意：赋值时只需给出函数名，不要带参数。（3）通过函数指针调用函数，调用格式如下：s=(*p)(实参)；第8章指针8.3指针与数组8.3.1指向一维数组的指针数组名是一个常量指针，它的值为该数组的首地址1.指向数组的

指针的定义方法与指向基本类型变量的指针的定义方法相同，例如：inta［10］=｛1,3,5，7，9｝;int*p;p=&a[2];(把数组元素a[2]的地址赋给指针变量p)p=a;(把数组的首地址赋给指针变量

p)第8章指针C语言规定：数组名代表数组首地址,是一个地址常量。因此，下面两个语句等价：p=&a[0];p=a;在定义指针变量的同时可赋初值：inta[10],*p=&a[0];(或int*p=a;)等价于：int*p;p=&a[0];两句。第8章指针

指向数组的指针变量p&a[0]13151719pa[0]:a[9]p[9]a+0p+1或a+1p+9或a+9*（a+9)或*(p+9)第8章指针2.通过指针引用数组元素*p=5;表示对p当前所指的数组元素赋以一个值5。C规定:p+1指向数组的下一元素(而不是将p值简单地加1)。p

+1意味着使p的原值（地址）加d个字节（d为一个数组元素所占的字节数）。如果p的初值为&a[0],则：（1）p+i和a+i就是a[i]的地址，或者说它们指向a数组的第i个元素（见下页图）。（2）*(p+i)或*(a+i)是p+i或a+i所指向的数组元素，即a[i]。（3）指向数组的

指针变量也可以带下标，如p[i]与*(p+i)、a[i]等价。第8章指针*(p+i)a数组a[0]a[1]a[2]a[i]a[9]pp+1,a+1p+i,a+ip+9,a+9•综上所述，引用一个数组元素有二法：（1）下标法：如a[i]形式；（2）指针法：

如*(a+i)或*(p+i)。其中a是数组名，p是指向数组的指针变量，其初值p=a。第8章指针main(){inta[10];inti;for(i=0;i<10;i++)scanf("%d",&a[i]);printf("\n");for(i=0;i<10;i++)printf("%d"

,a[i]);}例8.5用三种方法输出数组全部元素。(1)下标法第8章指针main(){inta[10];inti;for(i=0;i<10;i++)scanf("%d",&a[i]);printf("\n");for(i=0;i<10;i++)pri

ntf("%d",*(a+i));}(2)通过数组名计算数组元素地址,输出元素的值第8章指针(3)用指针变量指向数组元素main(){inta[10];int*p,i;for(i=0;i<10;i++)scanf("%d",

&a[i]);printf("\n");for(p=a;p<(a+10);p++)printf("%d",*p);}•三种方法的比较：用下标法比较直观，能直接知道是第几个元素；而用指针法则执行效率更高。第8章指针使用指针变量时，应注意：（1）指针变量可实现使本身的值改变。

P++合法；但a++不合法（a是数组名，代表数组首地址，在程序运行中是固定不变的。）（2）要注意指针变量的当前值。main(){inta[10];int*p,i;p=a;for(;p<a+10;p++)scanf("%d",p);printf("\n");for(;

p<(a+10);p++)printf("%d",*p);}不能&p增加：p=a；第8章指针（3）*p++相当于*(p++)，因为*与++优先级相同，且结合方向从右向左，其作用是先获得p指向变量的值，然后执行p=p+1

;（4）*(p++)与*(++p)意义不同，后者是先p=p+1，再获得p指向的变量值。若p=a，则输出*(p++)是先输出a［0］，再让p指向a［１］；输出*(++p)是先使p指向a［１］，再输出p所指的a［１］。（5）（*p）++表示

的是将p指向的变量值+１第8章指针8.3.2二维数组与多维数组的指针表示法1.二维数组的地址设有一个二维数组a,它有三行四列:inta[3][4];数组名a:代表整个二维数组的首地址，也就是第0行的首地址。a+i:代表第i行的首地

址。(见下页图)第8章指针数组名a代表整个二维数组的首地址:a[0]a[1]a[2]a===19173111971523上图a数组包含三个元素:a[0],a[1],a[2].而每个元素又是一个一维数组,它包含4个元素(即4个列元素),

如:a[0]又包含:a[0][0],a[0][1],a[0][2],a[0][3].第8章指针•一维数组名a[i]:代表第i行的首地址，即第i行中第0列元素的地址（既&a[i][0])。•a[i]+j:代表第i行中的第j个元素的地址,即为&a[i][j]。注意

：地址变化的单位数值在不同的场合的实际字节数是不同的：‚a+1”中的‚1”实际代表数组中一行元素所占的总字节数；‚a[i]+1”中的‚1”代表数组中一个元素所占的字节数。第8章指针a+2a数组a[0]a[1]a[2]aa+1(20

00)(2008)(2016)a代表第0行的首地址,a+1代表第1行的首地址,a+2代表第2行的首地址.每行存放4个整型数据(即1个元素占2个字节),因此,这里+1的含义是:+4*2=+8个字节.第8

章指针2000120023200452006720089201011201213201415201617201819202021202223aa+1a+2a[0]+1a[0]+2a[0]+3行地址,元素地址的表示法第8章指针例8.6

用指针表示法输出二维数组的各元素。#include<stdio.h>main(){staticinta[2][3]={{0,1,2,},{3,4,5}};intk,j,*p;for(j=0;j<2;j++)/*方式1*

/{for(k=0;k<3;k++)printf("%5d",*(a[j]+k))；/*a[j]是j行首地址，a[j]+k是j行k列元素的地址*/putchar(‘\n’);}putchar(„\n‟);第8章指针接上页：for(j=0;j<2;j++)/*方式2*/{for(k=0

;k<3;k++)printf("%5d",*(*(a+j)+k))；/**(a+j)是j行首地址，*(a+j)+k是j行k列元素的地址*/putchar(‘\n’);}p=a;/*p指向数组的第一个元素*/for(j=0;j<2;j++)/*方式3*/{for(k=0;k

<3;k++)printf("%5d",*(p++))；/*输出p所指示的元素*/putchar(‘\n’);}}第8章指针输出的结果是：0１２3450１２3450１２345第8章指针2.指向二维数组的指针变量有两种情况:一是直接指向数组元素的指针变量；二是指向一个含有m个元素的

一维数组。这两种不同形式的指针变量，其使用方法不同。(1)指向数组元素的指针变量,即简单指针变量，如：int*p,a[3][4];p=&a[1][2];(2)指向由m个元素组成的一维数组的指针变量定义形式：类型（*指针变量）[元素个数]如：int(*p)[4

];第8章指针注意：（1）int(*p)[4];定义一个指针变量p,p指向包含4个元素的一维数组。（2）p+i与*(p+i)的区别:p+i是指向第i行的指针（第i行的首地址）；*(p+i)是指向第i行第1个元素的地址；两者数值相等，但含义不同：p+i的增值将以行长为单位，而*(p+i)增值将以元素

长度为单位。第8章指针即：p+i+1将指向第i行再下一行的首地址，而*(p+i)+1将指向第i行首元素的下一个元素地址。(见下图)设inta[3][4],(*p)[4];p=a;P,aP+1P+2a[0]a[1]a[2]如果p先指向a[0],则p+1不是指向a[0]

[1],而是指向a[1]第8章指针例8.7main(){staticinta[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};int(*p)[4],i,j;p=a;scanf("i=%d,j=%d",&i,&j);printf("a[%d][%d]=%d\

n",i,j,*(*(p+i)+j));}第8章指针8.4指针与字符串8.4.1字符串的指针表示法回顾：字符串可以保存在字符数组中，如。main(){staticcharstring[]="ILoveChi

na!";printf("%s\n",string);}运行时输出：ILoveChina!第8章指针用字符指针指向字符串:字符指针变量的定义：char*指针变量;如：char*p;(1)在定义时初始化指针变量使指针

指向一个字符串。main(){char*string=“ILoveChina!”;(初始化string)printf("%s\n",string);}运行时也输出：ILoveChina!第8章指针char*str=“Ilovec

hina”,str1[40];等价于下列两句：char*str;str=“Ilovechina”;以上语句的含义：定义str为指针变量，它指向字符型数据，且赋值语句把字符串‚Ilovechina”的首地址赋给了指针变量str。对字符串的整体输出实际上还是从指针所指示

的字符开始逐个显示（系统在输出一个字符后自动执行p++），直到遇到字符串结束标志符‘\0’为止。而在输入时，亦是将字符串的各字符自动顺序存储在p指示的存储区中，并在最后自动加上‘\0’。Str1=“Ilovechina”;??第8章指针（2）用指针变量来实

现对字符串的访问例8.8将一已知字符串第n个字符开始的剩余字符复制到另一字符串中。main(){inti,n;chara[]="computer";charb[10],*p,*q;p=a;q=b;scanf("%d",&n);if(strl

en(a)>=n)p+=n-1;/*指针指到要复制的第一个字符*/第8章指针for(;*p!='\0';p++,q++)*q=*p;*q='\0';/*字符串以’\0‟结尾*/printf("Stringa:%s\n",a);pri

ntf("Stringb:%s\n",b);}输入:3↙输出:computermputer考虑一下，若输出语句改为如下语句会如何？printf(“stringais:%s\n”,p);printf(“stri

ngbis%s\n”,q);第8章指针8.4.2字符串数组字符串数组：是指数组中的每个元素都是一个存放字符串的数组。字符串数组可以用一个二维字符数组来存储。例如：charlanguge[3][10];数组的第一个

下标决定字符串的个数，第二个下标是字符串的最大长度（实际最多9个字符，‘\0’占一位置）。可以对字符串数组赋初值。例如：charlanguge[3][10];={“Basic”,“c++”,“pascal”}第8章指针8.5指针数组与命令行参数

8.5.1指针数组指针数组：是指针变量的集合。即它的每一个元素都是指针变量，且都具有相同的存储类别和指向相同的数据类型。指针数组的定义形式为：类型标识符*数组名[数组长度说明]；例如：int*p[10];由于[]比*的优先级高，因此p先与[1

0]结合成p[10]，而p[10]正是数组的定义形式，共有10个元素。最后p[10]与*结合,表示它的各元素可以指向一个整型变量。第8章指针指针数组广泛应用于对字符串的处理例如有定义：char*p[3]；定义了一个具有三个元素p[0]，p[1]，p[2]的指针数组。每个元素都可以指向

一个字符数组，或字符串。若利用数组初始化，则：char*p[3]={“Basic”,“c++”,“pascal”};P[0]指向字符串‚Basic”；P[0]指向字符串“c++”；P[0]指向字符串“pasc

al”；第8章指针例8.9字符指针数组的赋值#defineNULL0main(){staticchara[]=“Fortran”;staticcharb[]=“COBOL”;staticcharc[]=

“Pascal”;inti;char*p[4];p[0]=a;p[1]=b;p[2]=c;p[3]=NULL;for(i=0;p[i]!=NULL;i++)printf(“Language%dis%s\n”,i+1,p[i

]);}第8章指针例8.10有若干本书，将书名按字典顺序排序#include<stdio.h>#include<string.h>main(){char*bname[]={"ProgramminginAN

SIC","BASIC","VisualC++6.0Programming","TRUBOC2.0"};inti,m;voidsort(char*name[],int);m=sizeof(bname)

/sizeof(char*);/*字符串个数*/sort(bname,m);/*排序，改变指针的连接关系*/printf("\n");for(i=0;i<m;i++)/*输出排序结果*/printf("%8s",bname[i]);}第

8章指针voidsort(char*name[],intn)/*选择排序*/{char*t;inti,j,k;/*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;/*

第j个元素更小*/if(k!=i)/*最小元素是该趟的第一个元素则不需交换*/{t=name[i];name[i]=name[k];name[k]=t;}}}输出结果为：BASICProgramminginANSICTRUBOC2.0VisualC++6.0Programming第8章指针注

意：(1)字符数组中每个元素可存放一个字符，而字符指针变量存放字符串首地址，而不是存放在字符指针变量中。(2)对字符数组，与普通数组一样，不能对其进行整体赋值，只能给各个元素赋值，而字符指针变量可以直接用字符串常量赋值。例如，若有如下定义：

chara[10];char*p;则语句a=”computer”；是非法的，因为数组名a是一个常量指针，不能对其赋值。只能对各个元素分别赋值：a[0]=’c’;a[1]=’o’;a[2]=’m’;a[3]=’p’;……;a[7]=’r’;但语句:p=”com

puter”;是合法的。第8章指针8.5.2指针数组与命令行参数在操作系统命令状态下，可以输入程序或命令使其运行，称命令行状态。输入的命令（或运行程序）及该命令（或程序）所需的参数称为命令行参数。如:

copyfdfscopy是文件拷贝命令，fd、fs是命令行参数。main函数是可以有参数的，但与普通函数不同。带形参的main()函数的一般形式是：main(intargc,char*argv[]){…}形参argc记录命令行中字符串的个数，a

rgv是一个字符型指针数组，每一个元素顺序指向命令行中的一个字符串。第8章指针1.main()函数的形参与实参main（）函数由系统自动调用，而不是被程序内部的其它函数调用，main()函数所需的实参不可能由程序内部得到，而是由系统传送

。main（）函数所需的实参与形参的传递方式也与一般函数的参数传递不同，实参是在命令行与程序名一同输入，程序名和各实际参数之间都用空格分隔。格式为：执行程序名参数1参数2……参数n形参argc为命令行中参数的个数（包括执行程序名），其值大于或等于1，而不是象普通C语言函数一样接受第一个实参

。形参argv是一个指针数组，其元素依次指向命令行中以空格分开的各字符串。即：第一个指针argv[0]指向的是程序名字符串,argv[1]指向参数1，argv[2]指向参数2，……，argv[n]指向

参数n。第8章指针2.命令行参数的传递示例例8.11分析下列程序，指出其执行结果，该程序命名为exam.c,经编译连接后生成的可执行程序为exam.exe#include<stdio.h>main(intargc,char*argv[])

{inti=0；printf(“argc=%d\n”,argc);while(argc>=1){printf(“\n参数%d：%s”,i,*argv);i++;argc--;argv++;}}第8章指针输出结果：argc=4参数0：exa

m参数1：Turbo_c参数2：C++参数3：Vc程序开始运行后，系统将命令行中字符串个数送argc,将四个字符串实参：exam、Turbo_c、C++、Vc的首地址分别传给字符指针数组元素argv[0]、argv

[1]、argv[2]、argv[3]。若运行该程序时的命令行输入的是：examTurbo_cC++Vc第8章指针8.6程序举例例8.12输入一个十进制正整数，将其转换成二进制、八进制、十六进制数输出分析：(1)将十进制数n转换成r进制数的方法是：n

除以r取余数作为转换后的数的最低位。若商不为0,则商继续除以r,取余数作为次低位……,以此类推，直到商为0为止。(2)对于十六进制数中大于9的六个数字是用A,B,C,D,E,F来表示。(3)所得余数序列转换成字符保存在字符数组a中。

(4)字符‘0‟的ascii码是48,故余数0~9只要加上48就变成字符‘0‟~„9‟了；余数中大于9的数10~15要转换成字母,加上55就转换成‘A‟、‘B‟、‘C‟、‘D‟、‘E‟、‘F‟了。(5)由于求得的余数序列是低位到高位，而屏幕显示先显示高位，所以输出数组a时要反向进行。第8章指针#i

nclude"stdio.h"main(){inti,radix;longn;chara[33];voidtrans10_2_8_16(charb[],longm,intbase);printf("\nInputradix(2,

8,16):");/*输入转换基数*/scanf("%d",&radix);printf("\nInputapositiveinteger:");/*输入被转换的数*/scanf("%ld",&n);trans

10_2_8_16(a,n,radix);for(i=strlen(a)-1;i>=0;i--)/*逆向输出字符串*/printf("%c",*(a+i));/**（a+i）即a[i]*/puts("\n");}第8章指针voidtrans10_2_8_16(char*p,l

ongm,intbase){intr;while(m>0){r=m%base;/*求余数*/if(r<10)*p=r+48;/*小于10的数转换成字符后送p指向的元素*/else*p=r+55;/*数

10~15转换成A~F后送p指向的元素*/m=m/base;p++;/*指针下移*/}*p='\0';/*在最后加上字符串结束标志*/}输入：Inputradix(2,8,16):16Inputapositiveinteger:435678输出：6A5DE

第8章指针本章小结针是C语言的一种构造数据类型，它是C语言的一个特色，使用指针的优点主要有：（1）提高程序执行效率；（2）使用指针变量作为函数参数，可以从函数中返回多个值；（3）使用指针变量可以灵活处理字符串；（4）实现存储空间的动态分配。但指针的灵活性也使得程序设计过程容易产生

一些难以发现的错误，因此使用指针时应当小心谨慎，多进行上机实践，在实践中积累经验。