一、单选题
1、以下叙述中正确的是
A、即使不进行强制类型转换，在进行指针赋值运算时，指针变量的类型也可以不同
B、如果企图通过一个空指针来访问一个存储单元，将会得到一个出错信息
C、设变量p是一个指针变量，则语句p=0;是非法的，应该使用p=NULL;
D、指针变量之间不能用关系运算符进行比较
解析：答案选B
A、一个指针变量只能指向同一种数据类型的变量，即类型要一致，如果类型不同，需要强制类型转换才行。选项A错误。
B、在C语言中，空指针表示不指向任何地址空间，如果访问一个空指针，将会运行出错。选项B正确。
C、要使一个指针变量指向为空，p=0或p=NULL;后一种要求#include <stdio.h>。选项C错误。
D、指针变量可以用关系运算符进行比较。选项D错误。
2、以下程序段完全正确的是
A、int *p; scanf(“%d”, &p);
B、int *p; scanf(“%d”, p);
C、int k, *p=&k; scanf(“%d”, p);
D、int k, *p; *p=&k; scanf(“%d”, p);
解析：答案选
选项A、B中只定义了指针变量p，没有指向，不能用scanf语句赋值，而且A中的scanf语句的p已经是变量地址，不需要&运算符。选项A错误。
C、此处*p=&k表示定义了指针变量p，并对p初始化，p指向变量k。选项C正确。
D、p=&k;此语句中的p表示的是p指向的变量，&k表示的是k的地址，两端数据类型不一致，应该改成p=&k。选项D错误。
3、执行下面程序后，变量a的值为________。
int *p, a, b=2;
p=&a; *p=10; a=*p+b;
A、13
B、12
C、11
D、编译错误
解析：答案为B
代码讲解：p为指向变量a的地址，因此解引用操作p=a,执行完p=10;之后，a=10，a=*p+b;等同于a=a+b=2+10=12。选项B正确。
程序运行结果：
4、若有定义语句：int year=2015，*p=&year;以下不能使变量year中的值增至2016的语句是（ ）。
A、*p+=1;
B、(*p)++;
C、++(*p);
D、*p++;
解析：答案为D
A、p+=1;等同于p=*p+1;。选项A正确。
B、(*p)++;，对指针p指向的整型变量进行自增。选项B正确。
C、++(*p);，对指针p指向的整型变量进行自增。选项C正确。
D、*p++;自增操作符比解引用操作符优先级高，但是此处的++是后置++，因此先执行解引用操作，指针p再自增1，并不能改变变量year中的值，而是改变了p这个指针变量。选项D错误。
5、以下程序
#include <stdio.h>
void fun(int a)
{ int b=2;
a=b; a =a * 2; printf("%d,",a);
}
int main()
{ int k=3;
fun(k); printf("%d\n", k); return 0;
}
则程序的输出结果是________。
A、4,3
B、4,4
C、6,3
D、6,6
解析：答案选A
代码讲解：函数fun()中的形参a为动态局部变量，当函数被调用时，函数调用时，形参和实参的关系为单向值传递，即：实参的值传递给形参。因此形参a的初值为k的值，在函数中赋值为b的值2，并被修改为4，所以其输出为4，主函数中k的值根据形参和实参单向传值调用关系，其值不变为3。选项A正确。
程序运行结果：
6、以下程序
#include <stdio.h>
void fun(int *a)
{ int b=2;
a=&b; *a = *a * 2; printf("%d,", *a);
}
int main( )
{ int k=3, *p=&k;
fun(p); printf("%d,%d\n", k, *p); return 0;
}
则程序的输出结果是________。
A、4,3,3
B、4,3,4
C、6,3,6
D、6,6,6
解析：答案选A
代码讲解：函数fun()的形参为局部指针类型，主函数中的指针变量p指向k，当调用fun函数时，根据形参与实参的关系，实参的值传递给形参，此时形参a=p，即a也指向变量k，但是在函数fun中，a的指向改变了，指向b，因此a修改的是b的值为4，fun()中输出b的值4，主函数中 k的值没有改变，因此输出k和p都为3。选项A正确。
程序运行结果：
7、有以下程序
#include <stdio.h>
void fun (int *p)
{ printf ("%d\n", p[5]); }
int main( )
{ int a[10]= {1,2,3,4,5,6,7,8,9,10};
fun(&a[3]);
return 0;
}
程序运行后的输出结果是________
A、5
B、6
C、8
D、9
解析：答案选D
代码讲解：fun()函数传址调用，传递的是a[3]的地址，因此在函数中的数组首元素地址是a[3]的地址，所以p[5]=a[8]=9，因此打印：9。
程序运行结果：
8、有以下程序
#include<stdio.h>
int main( )
{ int a[]={1, 2, 3, 4, 5} ；
int x, y, *p；
p=a；
x=*(p+2)；
printf("%d：%d \n", *p, x)；
return 0;
}
程序运行后的输出结果是________。
A、1:3
B、1:1
C、3:3
D、3:1
解析：答案选A
代码讲解：p为指向数组a首元素的指针，数组中，指针加1减1会跳过一个数组元素类型的大小，因此p+2为指向a[2]的地址，而p的值并未发生改变，所以p=a[0]=1，x=(p+2)=a[2]=3，所以打印：1：3。
程序运行结果：
9、有以下程序
#include <stdio.h>
#include <stdlib.h>
void fun(int *p1,int *p2,int *s )
{ int c;
s=&c;
*s = *p1 + *(p2++);
}
int main()
{ int a[2]={1,2 }, b[2]={10,20}, *s=a;
fun( a,b,s ); printf("%d\n", *s ); return 0;
}
程序运行后的输出结果是________。
A、11
B、10
C、1
D、2
解析：答案选C
**代码讲解：**主函数中的指针变量s指向数组a第一个元素a[0]，此时s的值为1，函数fun()的三个参数均为指针变量，当被调用时，把a,b和s的值分别传值给形参p1,p2和s。在函数fun中，形参s与实参s是不同的指针变量，其初始指向为指向a[0]，但语句s=&c;使其指向发生变化，指向局部变量c，因此fun()函数中的s改变的是c的值，而不能改变a[0]的值，因此，主函数中*s的值（即a[0]的值）没有被改变，输出还是为1。
程序运行结果：
10、下面程序的运行结果是________。
int main()
{ int a[ ]={1,2,3,4,5,6,7,8,9,10},*p=a+5;
printf("%d",*--p); return 0;
}
A、4
B、a[4]的地址
C、3
D、5
解析：答案选D
**代码讲解：**指针加1减1会跳过一个数组元素类型的大小，因此—p使指针的指向由a[5]改变为指向a[4]，然后解引用，因此打印：5。选项D正确。
程序运行结果：
11、已有声明“int a[4]={4,3,8,6},*pa=a, i;”，以下语句中有语法错误的是________。
A、for(i=0; i<4; i++) a++;
B、for(i=0; i<4; i++) (*a)++;
C、for(i=0; i<4; i++) pa++;
D、for(i=0; i<4; i++) (*pa)++;
解析：答案选A
A、for(i=0; i<4; i++) a++;，a是数组名，a++无意义。选项A错误。
B、for(i=0; i<4; i++) (*a)++;，(a)中，a是首元素地址，因此a=4，循环4次，4变为8。选项B正确。
C、for(i=0; i<4; i++) pa++;，pa是指向首元素的指针，数组中，指针加1减1会跳过一个数组元素类型的大小，因此循环4次，pa最终会指向a[3]。选项C正确。
D、for(i=0; i<4; i++) (*pa)++;，(pa)中，pa是首元素地址，因此pa=4，循环4次，4变为8。选项B正确。
12、有以下程序
#include <stdio.h>
void fun( int *a,int n)
{ int i,t;
for(i=0; i<n/2; i++) { t=a[i]; a[i]=a[n-1-i]; a[n-1-i]=t; }
}
int main( )
{ int a[10]={1,2,3,4,5,6,7,8,9,10},i,*p=a;//5 4 3 2 1 6 7 8 9 10
fun(p,5);
for(i=2; i<8; i++) printf("%d",a[i]);
printf("\n"); return 0;
}
输出结果为：_________
A、321678
B、876543
C、1098765
D、345678
解析：答案选A
代码讲解：fun()函数进行传址调用，函数内部的for循环的作用是将前n=5个元素进行对称交换，数组内容发生变化，a[10]= {5,4,3,2,1,6,7,8,9,10}离开函数后，打印a[2]=3到a[7]=8，因此打印：321678。选项A正确。
程序运行结果：
13、以下程序
void prtv(int *x)
{ printf("%d\n",++*x); }
int main( )
{ int a=25;
prtv(&a);
return 0;
}
程序输出是________。
A、23
B、24
C、25
D、26
解析：答案选D
代码讲解：prtv(&a);函数传址调用，因此在函数内部可以用解引用操作符*修改函数外部a的值，这里是自增1，因此打印26。
程序运行结果：
14、以下程序程序运行结果是________。
#include <stdio.h>
int b=2;
int fun(int *k )
{ b=*k+b;
return (b);
}
int main()
{ int a[10]={1,2,3,4,5,6,7,8}, i;
for(i=2;i<4;i++)
{ b=fun(&a[i])+b;
printf("%d ",b);
}
printf("\n");
return 0;
}
A、10 12
B、8 10
C、10 28
D、10 16
解析：答案选C
代码讲解：此题中的变量b是全局变量，因此无论是在函数内部或是外部调用变量b，全局变量b都会被修改，函数fun()是传址调用，两次循环分别传递了数组中a[2]=3和a[3]=4的地址，第一次函数调用返回值为5，全局变量b=5，b=5+5=10，打印：10；第二次函数调用返回值为14，全局变量b=14,b=14+14=28，打印：28。选项C正确。
程序运行结果：
15、下列语句组中，正确的是 ________。
A、char *s; s＝"Olympic";
B、char s[7]; s＝"Olympic";
C、char *s; s＝{“Olympic”};
D、char s[7]; s＝{“Olympic”};
解析：答案选A
字符数组名是指针常量，常量的值在程序中不能修改，所以选项B和D均错，选项A和C中的s是字符指针变量，可以修改其值，C中的赋值方法是错误的，不能用“{}”号，A是对的。而这样赋值是正确的char *s＝{“Olympic”};。
16、有定义char *s1；，其含义是________。
A、分配指针空间及串空间
B、不分配指针空间和串空间
C、分配串空间，不分配指针空间
D、不分配串空间，分配指针空间
解析：答案选D
17、以下程序
#include <stdio.h>
#include <string.h>
char *a="are";
char *b="what are you doing";
int main( )
{ char *p;
p=strstr(b,a)+strlen(a)+1;
printf("%s\n",p);
return 0;
}
运行结果是________。
//strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。如果是，则该函数返回str2在str1中首次出现的内存地址（指针）；否则，返回NULL
A、are you doing
B、what are you doing
C、you doing
D、doing
解析：答案选C
代码讲解：strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。如果是，则该函数返回str2在str1中首次出现的内存地址（指针）；本题中a="are"是b="what are you doing"的字串，因此strstr(b,a)会返回are在what are you doing中首次出现的内存地址，即b数组中are中的字符a的地址，strstr(b,a)+strlen(a)+1实现的功能就是跳过a子串和之后的空格，因此p是指向are后面的y字符，所以%s打印：you doing。
程序运行结果：
18、有以下函数：
int fun(char *s)
{ char *t＝s；
while(*t＋＋)；
return(t－s)；
}
该函数的功能是________。
A、计算s所指字符串的长度
B、比较两个字符串的大小
C、计算s所指字符串占用内存字节的个数
D、将s所指字符串复制到字符串t中
解析：答案选C
首先可以排出B和D，因为是传址调用，s指向的是字符串首元素地址然后赋值给形参指针t，进入while循环，直到指针遇到0也就是’\0’时跳出循环，因此指向数组元素的指针，当其自增1或自减1，会直接跳过一个元素的字节大小，指向下一个元素，但是指针和指针的减法运算的结果仍然是之间占用的内存字节的个数。选项C正确。
19、以下选项中，能正确进行字符串赋值的是________。
A、char *s=“ABCDE”;
B、char s[5]={‘A’, ‘B’, ‘C’, ‘D’, ‘E’};
C、char *s; gets(s);
D、char s[4][5]= {“ABCDE”};
解析：答案选A
A、s是一个指向字符串“ABCDE”首元素A的指针。选项A正确。
B、B选项赋值没有问题，但是缺少字符串结束字符’\0’。选项B错误。
C、s是野指针，gets函数访问会出错。选项C错误。
D、字符串数组，后面没有大括号。选项D错误。
20、有以下程序
#include <stdio.h>
#include <string.h>
int main( )
{ char a[10]="abc",*b="312", *c="xyz";
strcpy(a+1,b+2);
puts(strcat(a,c+1));
return 0;
}
程序运行后的输出结果是________。
A、a12cyz
B、12yz
C、a2yz
D、bc2yz
解析：答案选C
代码讲解：strcpy(a+1,b+2);因为数组名是首元素地址，因此a+1可以理解为元素a[1]，b+2可以理解为元素b[2]，执行strcpy(a+1,b+2);语句后，a[1]及之后的2个元素，被覆盖为b[2]= ‘2’以及最后的’\0’把字符’c’覆盖，因此a[10]= “a2”，strcat(a,c+1);语句执行字符串拼接，识别到a的末元素’\0’之后，删除a的末元素’\0’，并将c[1]= 'y’及之后的字符，即"yz"拼接到"a2"之后，因此打印结果为：a2yz。选项C正确。
程序运行结果：
21、以下程序
int a[3][3]={{2},{4},{6}};
int main( )
{ int i,*p=&a[0][0];
for(i=0; i<2; i++)
{
if(i==0)
a[i][i+1]=*p+1;
else
++p;
printf("%d",*p);
}
return 0;
}
程序的运行结果是________
A、23
B、26
C、33
D、36
解析：答案选
代码讲解：
将a[0][1]元素的值修改为a[0][0]+1=2+1=3，因此修改后数组元素内容如下：
第一次循环，i=0，进入if语句，修改a[0][1]的值为3，但是指针p仍然指向的是数组首元素地址，因此解引用地址p后进行打印，也就是打印a[0][0]=2；
第二次循环，i=1，进入else语句，p指针加1，跳过一个元素，也就是跳过四个字节，指向第二个元素，a[0][1]=3，也就是打印a[0][1]=3。所以最终打印：23。
程序运行结果：
22、结构体定义如下：
struct STD
{ char name[10];
int age;
char sex;
}s[5],*ps;
ps=&s[0];
则以下scanf 函数调用语句中错误引用结构体变量成员的是________。
A、scanf(“%s”,s[0].name);
B、scanf(“%d”,&s[0].age);
C、scanf(“%c”,&(ps->sex));
D、scanf(“%d”,ps->age);
解析：答案选D
代码讲解：struct STD定义了含三个成员的结构体，struct STD是结构体类型，s[5]是结构体数组变量，数组中的5个元素都是struct STD结构体类型，ps是指向struct STD结构体类型的指针变量，从ps=&s[0];可以直到ps是指向s[0]的指针。
A、s[0].name，下标引用访问结构体数组中的第0个元素中的name成员，%s格式化输入。选项A正确。
B、&s[0].age，下标引用访问结构体数组中的第0个元素中的age成员，%d格式化输入。选项B正确。
C、&(ps->sex)，指针访问ps指针指向的结构体中的sex成员，%c格式化输入。选项C正确。
D、ps->age，指针访问ps指针指向的结构体中的age成员，%d格式化输入，但是age是整型变量，scanf输入时，应表达为&(ps->age)。选项D错误。
二、填空题
23、假定指针变量p指向对象的值为20，p+1指向的对象值为40，则*p++的值为_____。
解析：答案为：20
++的优先级比高，但是此处的++是后置++，因此先执行p，在执行p++，所以*p++=20。
24、若有程序段”int a[10],*p=a,*q; q=&a[5]”，则表达式q-p的值为________。
解析：答案为：5
数组名即是首元素a[0]的地址，p=&a[0]，q=&a[5]，指针相减，得到的结果是中间元素的个数，即a[0]、a[1]、a[2]、a[3]、a[4]五个元素，因此p-q=5。
25、当数组名作函数实参时，它传递给函数的是__________。
解析：答案为：数组首元素的地址
26、如果以下程序的第一个输出结果为1000，则第二个输出结果是________。
#include <stdio.h>
int main()
{ int a[ ]={1,2,3,4,5,6,7},*p;
p=a;
printf(“%d\n”,p);
printf(“%d\n”,p+6);
return 0;
}
解析：答案为：1024
代码讲解：p+6，跳过6个int类型的元素，因此printf(“%d\n”,p+6);打印1000+4*6=1024。
27、以下程序的输出结果是________。
int main( )
{ char s[]=“nanjing”,*p;
for(p=s; p<s+2; p++) puts§;
return 0;
}
解析：答案为：nanjing anjing
代码讲解：指针变量p指向字符数组s,第一次循环p指向s[0]，输出以s[0]开始的字符串，其值为”Nanjing”。第二次循环p指向s[1]，输出以s[1]开始的字符串，其值为”anjing”。
28、以下程序的功能是输入一行字符并作为字符串存放在字符数组中，然后输出。
请完成程序填空：
int main( )
{ int i;
char s[40],*p;
for (i=0; i<39; i++)
{ *(s+i)=getchar();
if(s[i]==‘\n’) break; //以回车作为输入字符串结束的标志
}
(1)____; //完整的字符串最后一个字节应该是什么？
(2)____ ; //是否该为下一句做准备？
while(*p) putchar(*p++); //逐个输出P指向的字符
return 0;
}
解析：答案为：(1) s[i]=‘\0’ (2) p=s
代码讲解：for循环将输入的字符全部存入字符数组里面，由于程序的功能是输入一行字符并作为字符串存放在字符数组中，因此要在存放完毕之后再加上’\0’，循环结束的s+i指针指向的就是数组最后一个元素地址的后一个地址，因此在执行s[i]=‘\0’之前i已经执行过i++，不再需要额外自增1，直接使用s[i]=’\0’即可，因为需要执行输出语句，输出语句使用的是函数putchar(*p++);，逐个输出，参数为p地址，因此执行之前应该将p指针赋值为数组首元素地址，即语句p=s。
29、假设数组a中的数据已按照从小到大排序，以下程序功能是将a中具有相同值的元素删得只剩一个，且以每行4个数据的格式输出结果数组中的元素值。例如若数组a的初始数据为{1,1,1,2,3,3,3,3,4,5}，则删除后a数组为{1,2,3,4,5}。请填空。
#define N 20
int main( )
{ int a[N], i, j, m;
for (i=0; i<N; i++) scanf("%d",a+i);
m=i=N-1
while(i>=0)
{ if (*(a+i)==*(a+i-1))
//如果相邻两个元素相同，则把后面的所有元素向前平移一下，删除一个元素
{ for(j= __(1)________; j<=m; j++)
*(a+j-1)=*(a+j);
__(2)________;
//每删除一个元素则数组的长度应该减一
}
i--;
}
for(i=1; i<=m+1; i++)
{ printf("%4d",__(3)________); //输出处理过的数组元素
if ((i)%4==0) printf("\n");
}
return 0;
}
解析：答案为：(1) i+1 (2) m-- (3) a[i-1]
代码思路：
i是用来比较相邻两个元素是否相同，从后往前比较，用while循环遍历比较，如果遇到相同的两个元素，该元素下标为i，因此接着需要执行平移覆盖掉i这个元素，所以需要用下表为i+1这个元素去覆盖下标为i这个元素，因为下标为i之后的所有元素都要进行平移覆盖，因此此处也应是由循环执行，我们可以使用语句*(a+i)=(a+i+1)执行此操作，但是覆盖语句题中已经给出为(a+j-1)=*(a+j)，对比可知平移for循环的初始条件应是(1)处j=i+1，(2)处是执行数组长度减1，由m=i=N-1、j<=m以及i<=m+1可以知道m就是数组的长度，因此(2)处应是m–,第二个for循环是执行输出元素功能，for循环初始条件为i=1，不能直接作为数组首元素下标，数组从a[0]开始打印的话，每一个元素的下标应是a[i-1]。
30、以下程序的功能是将十进制正整数转换成十六进制。请填空。
#include <stdio.h>
#include <string.h>
int main( )
{ int a, i;
char s[20];
scanf("%d",&a); //输入待转换的10进制正整数
tran10_16(s,a);
for (i=__(1)________; i>=0; i--)//反序输出字符串内各个字符
putchar(*(s+i));
return 0;
}
void tran10_16(char *s, int b)
{ int j;
while(b>0)
{ j=b%16;
if(__(2)________)
*s=j+'0'; //把余数数值转换为对应的字符存入字符串
else
*s=j-10+'A';
b=b/16;
s++;
}
__(3) ________; //完整的字符串不应该只包含各个字符
}
解析：答案为：(1) strlen(s)-1 (2) j>=0&&j<=9 (3)s=‘\0’
代码解析：(1)处进行字符串反序输出，for循环进行遍历的话，putchar是用解引用操作符解引用指针进行数组元素的访问，从i—可以看出，循环的初始条件应该使得(s+i)是数组最后一个元素，但是代码到目前为止，并没有给出字符串的长度，而且从包含头文件#include <string.h>可知，在此处需要同时获取字符串的长度，使用strlen()函数，所以(1)处应填=strlen(s)-1，(2)处在函数tran10_16()内部，十六进制表示的数是由：0-9、A-F组成，while循环完成每一位余数从数值往字符的转变，s=j+‘0’;可知，当余数为0-9时，只需要将余数数值加上字符’0’即可得到位于’0’到’9’的个位数字字符，当if条件为假时，则是使用s=j-10+‘A’;语句完成10-15的数从数值往字母字符的转换，所以(2)处应填j>=0&&j<=9，第三处应在字符数组末尾加上字符’\0’变成字符串，因此(3)处应填*s=‘\0’。
31、以下程序运行结果是________。
#include <stdio.h>
int f(int *x,int *y,int z)
{
*x=*y; *y=z; z=*x;
return z;
}
int main( )
{
int a=5, b=6, c=7, d;
d=f(&a,&b,c);
printf("%d,%d,%d,%d\n",a,b,c,d);
return 0;
}
解析：答案为6,7,7,6
**代码讲解：**函数f(&a,&b,c);前两个参数是传址调用，最后一个参数是传值调用，在函数内部*x=*y;即a=6，则a的值赋值为6，*y=z;，即b的值赋值为7，而z=*x;即是z的值赋值为6，因为z是传值调用，函数的形参z是实参c的一份临时拷贝，离开函数后，函数栈帧会销毁，形参z也就销毁了，这里的z的改变不会影响到c的值，离开函数后，将函数返回值z赋值给变量d，d=6,最终打印：6,7,7,6
程序运行结果：
32、以下程序的运行结果是什么？
#include <stdio.h>
#include <string.h>
int fun(char *str)
{ int i, j, len;
len=strlen(str);
for(i=0, j=0; *(str+i); i++)
if(*(str+i)>='A'&&*(str+i)<='Z'||*(str+i)>='a'&&*(str+i)<= 'z')
*(str+j++)=*(str+i);
*(str+j)= '\0';
return len-j;
}
int main( )
{ char s[80]= "how123are6you78";
int n; n=fun(s);
printf("%d\n",n); //输出值是：___(1)_____。
printf("%s\n",s); //输出值是：___(2)_____。
return 0;
}
解析：答案为：6,6
**代码讲解：**首先我们需要知道fun()函数的功能，从for循环中的if语句我们可以知道，if语句的条件判断是判断字符是否是字母字符，如果条件为真，则进行下一步操作，所以这一步已经将字符串中的数字排除完，for循环将字符串中的字母提取出来，最终用len-j计算该字符串中数字的长度，也就是字符串中的数字字符个数，并作为函数的返回值赋值给n，因此打印：(1) 6,(2) howareyou。
程序运行结果：
33、以下程序的运行结果是________。
#include <stdio.h>
int fun1(int p[ ], int n)
{ int i, s=0;
for(i=0; i<n; i++) s+=p[i];
return s;
}
int fun2(int *s, int n)
{ if(n==1) return *s;
else return (*s)+fun2(s+1,n-1);
}
int main( )
{ int a[ ]={1,2,3,4,5};
printf("%d,%d", fun1(a,3), fun2(a,3) );
return 0;
}
解析：答案为：
代码讲解：函数fun1的功能：遍历法计算数组前三个元素之和；函数fun2的功能：递归法计算数组前三个元素之和。因此打印：6,6。
程序运行结果：
34、以下程序输出结果是_________
#include <stdio.h>
#include <string.h>
void fun(char *w, int m)
{ char s, *p1, *p2;
p1=w;//首元素地址
p2=w+m-1;//末元素的地址
while( p1<p2 )
{
s=*p1++; //s=*p1;p1++;
*p1=*p2; //*p1=*p2
*p2--=s; //*p2=s;p2--;
}
}
int main()
{ char a[ ]="123456";
fun( a, strlen(a) );
puts(a);
return 0;
}
解析：答案为：165561
代码讲解：函数fun的功能：功能一眼看过去可能会误认为是数组逆置存放，但是要注意函数功能与逆置函数还是有一定的区别的，不同之处在于指针移动的时机，函数若要完成数组元素逆置，需要将p1++和p2—放到while循环末尾，
如下fun1:
void fun1(char *w, int m)
{ char s, *p1, *p2;
p1=w;//首元素地址
p2=w+m-1;//末元素的地址
while( p1<p2 )
{
s=*p1;
*p1=*p2;
*p2=s;
p1++;
p2--;
}
}
程序运行截图：
此题中的fun函数功能是将数组元素后半部分元素对称放置在数组前半部分，因此打印：165561。
程序运行截图：
35、以下程序的输出结果是________。
#include <stdio.h>
#define PR(ar) printf ("%d,", ar)
int main()
{ int j , a[ ]={1,3,5,7,9,11,13,15}, *p=a+5 ;
for ( j=3 ; j ; j-- )
{ switch ( j )
{ case 1 :
case 2 : PR(*p++) ; break ;
case 3 : PR( *(--p) ) ;
}
}
return 0;
}
解析：答案为：9,9,11,
代码讲解：
*p=a+5，说明p为指向a[5]的指针。
(1)j=3，进入case 3 : PR( *(–p) ) ;即printf (“%d,”, *(–p) );打印a[4]：9, ，指针左移一位，指针现在指向a[4]；
(2)j=2，进入case 2 : PR(*p++) ; break ;即printf (“%d,”, *p++ );打印a[4]：9, ，指针右移一位，指针现在指向a[5]；
(3)j=1，进入case 1 : case 2 : PR(*p++) ; break ;即printf (“%d,”, *p++ );打印a[5]：11,，指针右移一位，指针现在指向a[6]；
(4)j=0，终止循环，因此打印：9,9,11,。
36、以下程序程序运行结果是________。
#include <stdio.h>
char s[ ]="ABCD";
int main()
{ char *p;
for(p=s;p<s+4;p++)
printf("%c:%s\n",*p, p);
return 0;
}
解析：答案为：
A:ABCD
B:BCD
C:CD
D:D
代码讲解：
(1)p指向s[0]地址，%c打印指针指向的字符，%s打印字符串，因此打印：A:ABCD
(2)p指向s[1]地址，%c打印指针指向的字符，%s打印字符串，因此打印：B:BCD
(3)p指向s[2]地址，%c打印指针指向的字符，%s打印字符串，因此打印：C:CD
(4)p指向s[3]地址，%c打印指针指向的字符，%s打印字符串，因此打印：D:D
37、以下程序的功能是对在输入的10个整数中查找某数x，如果找到则输出该数的数组元素下标，否则输出没找到，请填空使程序完整。
#include <stdio.h>
int main( )
{ int a[10], x, i;
printf("Enter 10 integers:\n");
for(i=0; i<10; i++)
scanf("%d",a+i);
printf("Enter x:");
scanf("%d",&x); //输入被查找的数
i--;
while( x != *(a+i) )
(1) ;
if( (2) )
printf("%5d的位置是:%4d\n", x, i);
else printf("%d 没找到!\n",x);
return 0;
}
解析：答案为：(1) i-- (2) i>=0
代码解析：while循环负责遍历数组元素，因为for循环遍历输入数值后i的值等于10，但是数组最后一个元素下标应为9，因此在while循环之前需要自减1，进入while循环后，从最后一个元素往前进行遍历，因此(1)处应填：i–，在(2)处的if语句中能判断为真时，就说明该数在数组中能找到对应的元素与之对应，while循环结束会有两种情况：第一种情况是在数组中找到了这个数，条件判断结果为假，跳出循环，此时的i>=0；第二种情况是遍历完整个数组都没有找到这个数，跳出循环，此时i<0，因此(2)处的条件判断应该属于是第一种情况，所以应填i>=0。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
