c语言 指针讲义 复习资料

第十章 指针 (10学时)

学习目的与要求：

1 、理解地址和指针的概念；

2 、重点掌握指针变量的定义和引用；

3 、重点掌握指向数组的指针和通过指向数组的指针操纵数组；

4 、重点掌握指向字符串的指针和通过指向字符串的指针操纵字符串 ； 5 、理解指向指针的指针、指针数组等概念。

重点：

1 、指针变量的定义和引用；

2 、指向数组的指针和通过指向数组的指针操纵数组；

3 、指向字符串的指针和通过指向字符串的指针操纵字符串

第1讲 知识归纳：

1、地址和指针的概念：

(1) 地址：内存区的每一个字节的编号 ；

(2) 指针：一个变量的地址称为该变量的指针，即地址就是指针，指针就是地址；

2、指向变量的指针变量：

(1) 指针变量：是指专门用来存放变量地址的一类变量 ； (2) 注意区分指针和指针变量的概念；

指针是地址；指针变量是存放地址的变量；

平时所说的定义一个指针，实际上是指定义一个指针变量；

3、指针变量的定义和引用：

(1) 定义指针变量格式： 基类型 * 指针变量名 ； (2) 如何确定指针变量的类型？

要定义的指针准备指向什么类型变量，该指针就是什么类型； (3) 如何让一个指针指向一个变量？ 将变量的地址赋值给指针变量； & -----取地址运算符；

如 ： int a =5 ;

int * pa ; int pa = &a ; (4) 指针变量的引用： *-----取内容运算符， 该运算符与指针变量结合，表示指针所指向的变量的内容； 如：printf (“ % d ,%d\\n “, * pa , a ) ; 下面是错误的：

int * pa ;

printf (“ % d \\n “, * pa ) ; //一个指针在没有指向一个确切的存储空间时，是不能使用 * pa

4、指针总结：

int a = 5 ; int * pa =&a ; 在定义指针，并指向某个变量后，我们可以得出如下结论： (1) *pa 等价于 a (2) pa 等价于 &a

(3) & * pa 等价于 &a 、 pa (4) * &a 等价于 a

基础训练(A)

一、选择题

1、已知：int *p,a;则语句“p=&a;”中的运算符“&”的含义是（ ）。 A）位与运算 B）逻辑与运算 C）取指针内容 D）取变量地址

2、已知：double d;希望指针变量pd指向d，下面对指针变量pd的正确定义是 （ ）。 A）double pd; B）double &pd C）double *pd D）double *(pd)

3、若x为整型变量，p是指向整型数据的指针变量，则正确的赋值表达式是( )。 A）p=&x B）p=x C）*p=&x D）*p=*x 二、填空题

1、要使指针变量与变量之间建立联系，可以用运算符 来定义一个指针变量，用运算符 来建立指针变量与变量之间的联系。

2、已知：int a=10,*p=&a;则“printf(\d,%d\\n\的输出结果是 。

3、已知：float f1=3.2,f2,*pf1=&f1;现在希望变量f2的值为3.2，可使用赋值语句 或 。 4、已知：int b=5,*p=&b;并且b的地址为4000，则“printf(\的输出结果是 。 三、阅读程序，回答问题。 1、main() { int var, *p;

var=100; *p=&var; var=*p+10;

printf(\}

运行结果：

2、# include void prtv(int *x)

{ printf(\}

main() { int a=25; prtv(&a); }

运行结果：

能力提高(B)

一、选择题

1、已知：int a,*p=&a;则下列函数调用中错误的是（ ）。 A）scanf(\）scanf(\C）printf(\）printf(\

2、已知：int i=0,j=1,*p=&i,*q=&j;错误的语句是（ ）。 A） i=*&j; B） p=&*&i; C）j=*p; D）i=*&q;

3、函数的功能是交换变量x和y中的值，且通过正确调用返回交换的结果。能正确执行此功能的函数是（ ）。

A）funa(int *x,int *y) { int *p;

*p=x; *x=*y; *y=*p; }

B）funb(int x,int y) { int t;

t=x; x=y; y=t; }

C）func(int *x,int *y) { *x=*y; *y=*x; }

D）fund(int *x,int *y) { int t;

t=*x; *x=*y; *y=t; }

二、阅读程序，写出运行结果 1、# include main() { int a,b; a=5;b=10;

printf(\swap(a,b);

printf(\}

swap(int x,int y) { int temp;

temp=x; x=y; y=temp;

printf(\}

运行结果：

2、# include main() { int a,b; a=5;b=10;

printf(\swap(&a,&b);

printf(\}

swap(int *px,int *py) { int temp;

temp=*px; *px=*py; *py=temp;

printf(\}

运行结果：

比较上面两个程序，试说明两者的区别？

第2讲 知识归纳：

1、指针变量做实参：

(1) 指针变量做实参，实质传的是指针所指向的变量的地址-----即传地址调用；

(2) 指针变量做实参 ，形参必须是指针，即通过形参指针操纵主调函数中的变量；

2、指向数组的指针变量：

(1) 定义一个指向数组元素的指针变量的方法，与定义指向变量的指针变量相同； (2) 使指针指向数组首地址 ：将数组名赋值给已定义的指针变量；

使指针指向数组的某一元素： 将数组元素地址赋值给已定义的指针变量； 如：int arr[ 10 ]; int * p ; //定义指针变量，类型与将要指向的数组类型一致； p = arr ; //p 指针指向 arr数组的首地址；等价于 p = & arr[0];

p = &a [ 9] ; // p 指针指向 arr数组的最后一个元素arr[9] ；

3、通过指针引用数组元素：

int arr[ 10 ]; int * p = arr ;

在定义指针，并指向某个数组的首地址后，我们可以得出如下结论：

(1) (1) p + i =arr + i = &arr[ i ] ，均表示 arr数组的第 i 个元素的地址 ； 指针变量加1 ，即在指针当前所指向的元素的地址基础上+ 一个数组元素的字节数 ；即 p + i*d //d是一个数组元素的字节数； （2） （2） *(p+i) = *(arr + i) = arr[i] , 均表示 arr 数组的第 i 个元素; (3)数组元素的两种表示方法：

下标法： arr[ i ] , p [ i ] // 均表示arr数组的第 i 个元素; 指针法： * ( p+i) , * (arr+i) //均表示arr数组的第 i 个元素;

4、在使用指向数组的指针变量时，应注意的问题：

int arr[ 10 ]; int * p = arr ;

在定义指针，并指向某个数组的首地址后: (1) p ++ ; 正确 ；但 arr++ ; 不正确 ；

因为 arr 表示数组名 ，是常量，不能执行 arr = arr + 1 ; (2) 要注意 指针变量的当前值；

(3) ) ( * p ) ++ ----表示p所指向的元素值加一 ；即 arr [ 0] ++ ;

* p ++ 、* ( p ++ ) ------ 先取指针所指向空间的内容, 即 arr[0] , 然后指针pa 下移一个存储空间, 指向 arr[1] ;

(4) * ++pa ------指针pa 先下移一个存储空间，然后取指针所指向空间的内容；

基础练习(A)

一、选择题

1、已知：int a[10],*p=a;则下面说法不正确的是 （ ）。

A）p指向数组元素a[0] B）数组名a 表示数组中第一个元素的地址 C）int a[10],*p=&a[0];与上述语句等价 D）以上均不对

2、已知：int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;则不能表示数组a中元素的表达式是 （ ）。 A）*p B）a[10] C）*a D）a[p-a] 二、填空题

1、在C语言中，指针变量的值增1，表示指针变量指向下一个 ，指针变量中具体增加的字节数由系统自动根据指针变量的 决定。

2、已知：int a[5],*p=a;则p指向数组元素a[0],那么p+1指向 。若“ printf(\的输出结果是200，那么：“ printf(\的输出结果是 。

3、对数组元素的引用方法有两种： 和 。设int a[10],*p=a;则对a[3]的引用可以是 或 。 4、在C程序中，可以通过三种运算来移动指针： 、 、 。 5、设有如下定义:

int a[5]={0,1,2,3,4},*p1=&a[1],*p2=&a[4];则p2-p1的值为 ______ ,*p2-*p1的值为 。 三、阅读程序，写出运行结果 1、main() { int a[10],i,*p; *p=a;

for (i=0; i<10; i++) scanf(\for (;p

执行程序，输入：0 1 2 3 4 5 6 7 8 9 运行结果：

2、main() { int a[10],*p; p=&a[0];

for (;p

for (p=a+9; p>=a; p--) printf(\}

执行程序，输入：0 1 2 3 4 5 6 7 8 9 运行结果：

能力提高(B)

一、选择题

1、已知:int a[]={1,2,3,4},y,*p=&a[1];则执行语句\之后,变量y的值为 （ ）。 A) 3 B) 2 C) 1 D) 4

2、已知:int a[]={1,2,3,4},y,*p=&a[0];则执行语句\之后,下面（ ）元素的值发生了变化。

A) a[0] B) a[1] C) a[2] D) 都没发生变化

3、已知:int x[]={1,3,5,7,9,11},*ptr=x;则能够正确引用数组元素的语句是 （ ）。 A) x B) *(ptr--) C) x[6] D) *(--ptr)

4、若有以下语句并且0<=k<6,则正确表示数组元素地址的语句是（ ）。 int x[]={1,3,5,7,9,11},*ptr=x,k;

A) x++ B) &ptr C) &ptr[k] D)&(x+1)

5、已知:int a[]={1,2,3,4,5,6},*p=a;则值为3的表达式是 （ ）。 . A) p+=2,*(p++) B) p+=2,*++p C) p+=3,*p++ D) p+=2,++*p

6、若第一个printf语句的输出为194,则第二个printf语句的输出为（ ）。

int a[10],*p=a; printf(\printf(\

A) 203 B) 212 C) 1a6 D)19d 二、阅读程序,写出运行结果 1、# include main()

{ int a[]={1,2,3,4,5}; int x,y,*p; p=&a[0]; x=*(p+2); y=*(p+4);

printf(\}

运行结果:

2、# include main()

{ int a[]={1,2,3,4,5,6}; int *p; p=a;

printf(\printf(\printf(\printf(\p+=3;

printf(\

}

运行结果: 三、程序填空

1、下面的程序实现从10个数中找出最大值和最小值.

int max,min;

find_max_min(int *p,int n) { int *q;

max=min=*p; for (q= ; ; q++) if ( ) max=*q; else if ( ) min=*q; }

main()

{ int i,num[10];

printf(\for (i=0; i<10; i++) scanf (%d\find_max_min(num,10);

printf(\} 四、编程

1、编写两个函数,分别完成一维数组的输入和输出.

main() { int a[10]; input(a,10); output(a,10); }

void input(int *p,int n) {

}

void output(int *p,int n) { }

第3讲 知识归纳：

1、数组、指针和函数的结合应用：

传值调用 变量名 变量地址 指针 传地址调用 数组名 数组 数组名或数组元素地址 指针 实参类型 的类型 要求形参变量名 传递的信变量的值 息 通过函数不能 调用能否 改变实参的值 变量的地址 能 数组的起始地址 能 数组的起始地址或数组元素地址 能 2、二维数组的地址问题：

int a [3][4] = { 1,2 ,3,4,5,6,7,8,9,10,11,12} ;

int * p = a ;

(1) (1) a ------数组名表示数组的首地址 ； 等价于 *( a + 0 ) 、* a

(2) (2) a [ i ] ------表示数组的第 i行的行地址，即 第 i行第一个元素的地址；

等价于 *( a + i ) 、* ( p + i ) ;

(3) (3) &a [ i ][ j ] ------表示数组的第 i行 j 列元素的地址； 等价于 *( a + i ) +j

和 *( p + i ) +j

(4) (4) a [ i ][ j ]----- 表示数组的第 i行 j 列元素；等价于 * ( *( a + i ) +j ) ;

和 * ( *( p + i ) +j ) ;

3、指向二维数组的行指针：

int a [3][4] = { 1,2 ,3,4,5,6,7,8,9,10,11,12} ;

int ( * p )[4 ] = a ; (1) (1) int ( * p )[4 ] = a ;

表示 p 是一个指向二维数组（一行有四个元素的）行地址的行指针； (2) p + 1 ; 行指针加 1 ，是加 一行元素的字节数的和；

p = p + 1 ; 行指针从当前行指向下一行；

基础练习(A)

一、选择题

1、已知:int a[3][4],*p=a;则p表示 （ ）。

A) 数组a的0行0列元素 B) 数组a的0行0的地址 C) 数组a的0行首地址 D) 以上均不对

2、已知:int a[3][4],*p;若要指针变量p指向a[0][0],正确的表示方法是 （ ）。 A) p=a B) p=*a C) p=**a D) p=a[0][0]

3、已知:double b[2][3],*p=b,下面哪个不能表示数组b的0行0列元素 （ ）。 A) b[0][0] B) **p C) *p[0] D) *p

4、设有说明int (*ptr)[M];其中的标识符ptr是 （ ）。

A) M个指向整型变量的指针

B) 指向M个整型变量的函数指针

C) 一个指向M个整型元素的一维数组的指针

D) 具有M个指针元素的一维指针数组,每个元素都只能指向整型变量 二、填空题

1、已知:下面程序段中第一个printf语句的输出是200,则第二个printf语句的输出是 ,第三

个printf语句输出是 。 int a[3][4],*p=a; printf(\printf(\printf(\

2、已知:int a[2][3]={1,2,3,4,5,6},*p=&a[0][0];则表示元素a[0][0]的方法有指针法: ,数组名法: 。 *(p+1)的值为 。 三、阅读程序,写出运行结果 1、main()

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

printf(\printf(\printf(\

printf(\}

假设数组a的首地址为3000,则运行结果为:

能力提高(B)

一、选择题

1、已知:int i,x[3][4];则不能把x[1][1]的值赋给变量i的语句是 （ ）。 A) i=*(*(x+1)+1) B) i=x[1][1] C) i=*(*(x+1)) D) i=*(x[1]+1}

2、已知:static int a[2][3]={2,4,6,8,10,12};正确表示数组元素地址的是 （ ）。 A) *(a+1) B) *(a[1]+2) C) a[1]+3 D) a[0][0] 二、阅读程序,写出运行结果 1、main()

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

m=(*ptr)*(*(ptr+2))*(*(ptr+4)); printf(\}

2、main()

{ int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,13}; int (*ptr)[4]; int sum=0,i,j; ptr=a;

for (i=0;i<3;i++) for (j=0;j<2;j++) sum+=*(*(ptr+i)+j); printf(\}

运行结果: 三、程序填空

1、下面程序通过指向整型的指针将数组a[3][4]的内容按3行*4列的格式输出,请给printf()填入适当的参数,使之通过指针p将数组元素按要求输出.

int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}},*p=a; main() { int i,j;

for (i=0; i<3; i++ ) for (j=0; j<4; j++ ) printf(\

第4讲 知识归纳：

1、指向字符串的指针变量：

(1) 定义指向字符串的指针：

char * 指针名 = 字符串 ；

如 char * ps = “I am a teacher .” ;

//这里是将 字符串的首地址存放在字符指针中，而不是将字符串中的字符存入指针； (2) 比较：

char * ps = “I am a teacher .” ; √

分开： char *ps ;

ps = “I am a teacher .” ; √

//因为 可以将字符串的首地址存放在指针中； char s [ 20 ] = “I am a teacher .” ; √ 分开： char s [20 ] ;

s = “I am a teacher .” ; ×

//因为 s 表示字符数组的首地址，是常量，不能在赋值号的左端，不能将字符串的首地址赋值给数组名；

(3) 再比较：

char s [20] ;

scanf ( “%s” , s ) ; √ 变换：char * ps ;

scanf ( “%s” , ps ) ; ×

// 错在 字符指针没有指向任何存储空间，不能给他输入字符串； 改成：char s [20] , * ps ; ps = s ;

scanf ( “%s” , ps ) ; √

//字符指针在没有指向一个确切的字符数组时，不能使用%s格式符，输入字符串；

2、字符串指针作函数参数：

传地址调用 实参 数组名 数组名 字符指针变量 字符指针变量 形参 数组名 字符指针变量 字符指针变量 数组名

基础练习(A)

一、选择题

1、已知:char str[]=\对指针变量ps的说明和初始化是（ ）。

A) char ps=str; B) char *ps=str; C) char ps=&str; D) char *ps=&str;

2、下面不正确的字符串赋值或赋初值的方式是（ ）。

A) char *str; str=\

B) char str[7]={'s','t','r','i','n','g'}; C) char str[10]; str=\

D) char str1[]=\3、已知:char b[5],*p=b;则正确的赋值语句是 （ ）。 A) b=\

4、已知:char s[20]=\则不能引用字母o的表达式是 （ ）。 A) ps+2 B) s[2] C) ps[2] D) ps+=2,*ps 5、下列对字符串的定义中,错误的是（ ）。

A) char str[7]=\B) char str[]=\C) char *str=\

D) char str[]={'F','O','R','T','R','A','N','\\0'};

6、已知:char c[8]=\则下面的输出语句中,错误的是（ ）。

A) printf(\C) for (i=0; i<7;i++) D) for (i=0; i<7; i++) printf(\

7、已知:char s1[4]=\则执行下面语句后输出为 （ ）。

ptr=s1;

printf(\

A) 字符'2' B) 字符'1' C) 字符'2'的地址 D) 不确定 二、阅读程序，写出运行结果 1、# include main()

{ char a[]=\char *ptr=a; while (*ptr!='\\0') { printf(\ptr++; } }

运行结果：

2、#include main()

{ char *str=\printf(\printf(\printf(\printf(\printf(\}

运行结果：

能力提高(B)

一、选择题

1、已知：char s[10],*p=s;则在下列语句中，错误的语句是 （ ）。 A）p=s+5; B）s=p+s; C）s[2]=p[4]; D）*p=s[0];

2、已知：char s[100]; int i=10;则在下列引用数组元素的语句中，错误的表示是 （ ）。 A）s[i+10] B）*(s+i) C）*(i+s) D）*((s++)+i

3、已知：int i; char *s=\执行语句“for ( i=0; *s++; i++) ;”之后，变量i的结果是 （ ）。

A）7 B）8 C）9 D）以上均是错误的 4、已知：char *s=\则执行语句“for(i=0;*s++; i++);”之后，变量i的结果是（ ）。 A）7 B）8 C）9 D）1 二、填空题

1、已知：char *s1=\则语句“printf(\\\t%s\\t%s\\n\的结果是 。

2、若：char *s1=\则语句“printf(\\\n\的结果是 。 三、阅读程序，写出运行结果 1、# include # include main()

{ char *p1=\ strcpy(str+2,strcat(p1,p2)); printf(\}

运行结果：（ ）

2、# include main()

{ char a[]=\for (ptr=a; ptr

本文来源：https://www.bwwdw.com/article/uwgv.html