|
一、选择题
（1）若有语句：char *line[5];，以下叙述中正确的是
A）定义line是一个数组，每个数组元素是一个基类型为char的指针变量
B）定义line是一个指针变量，该变量可以指向一个长度为5的字符型数组
C）定义line是一个指针数组，语句中的*号称为间址运算符
D）定义line是一个指向字符型函数的指针
（2）有以下程序
#include
main（）
{ char p[]={'a', 'b', 'c'}, q[10]={'a', 'b', 'c'};
printf（"%d %d\n", strlen（p）, strlen（q））;
}
以下叙述中正确的是
A）在给p和q数组置初值时，系统会自动添加字符串结束符，故输出的长度都为3
B）由于p数组中没有字符串结束符，长度不能确定；但q数组中字符串长度为3
C）由于q数组中没有字符串结束符，长度不能确定；但p数组中字符串长度为3
D）由于p和q数组中都没有字符串结束符，故长度都不能确定
（3）有以下程序，其中函数f的功能是将多个字符串按字典顺序排序
#include
void f（char *p[], int n）
{ char *t; int i,j;
for（i=0; i for（j=i+1; j if（strcmp（p[i],p[j]）>0）{ t=p[i]; p[i]=p[j]; p[j]=t; }
}
main（）
{ char *p[5]={"abc","aabdfg","abbd","dcdbe","cd"};
f（p, 5）;
printf（"%d\n", strlen（p[1]））;
}
程序运行后的输出结果是
A）2 B）3 C）6 D）4
（4）有定义语句:int b;char c[10]; ,则正确的输入语句是_____
A）scanf（"%d%s",&b,&c）;
B）scanf（"%d%s",&b,c）;
C）scanf（"%d%s",b,c）;
D）scanf（"%d%s",b,&c）;
（5）以下能正确定义一维数组的选项是_____
A）int a[5]={0,1,2,3,4,5};
B）char a[]={0,1,2,3,4,5};
C）char a={'A','B','C'};
D）int a[5]="0123";
（6）已有定义：char a[]="xyz",b[]={'x','y','z'};,以下叙述中正确的是_____
A）数组a和b的长度相同
B）a数组长度小于b数组长度
C）a数组长度大于b数组长度
D）上述说法都不对
（7）以下语句或语句组中，能正确进行字符串赋值的是
A）char *sp; *sp="right!";
B）char s[10]; s="right!";
C）char s[10]; *s="right!";
D）char *sp="right!";
（8）有以下程序
main（）
{
char s[]="159",*p;
p=s;
printf（"%c",*p++）;
printf（"%c",*p++）;
}
程序运行后的输出结果是
A）15
B）16
C）12
D）59
（9）有以下函数
fun（char *a,char *b）
{
while（（*a!='\0'）&&（*b!='\0'）&&（*a==*b））
{ a++; b++;}
return （*a-*b）;
}
该函数的功能是
A）计算a和b所指字符串的长度之差
B）将b所指字符串复制到a所指字符串中
C）将b所指字符串连接到a所指字符串后面
D）比较a和b所指字符串的大小
（10）有以下程序
point（char *p）
{
p+=3;
}
main（）
{ char b[4]={'a','b','c','d'},*p=b;
point（p）; printf（"%c\n",*p）;
}
程序运行后的输出结果是
A）a
B）b
C）c
D）d
（11） s12和s2已正确定义并分别指向两个字符串。若要求：当s1所指串大于s2所指串时，执行语句S;则以下选项中正确的是_____
A） if（s1>s2）S; B） if（strcmp（s1,s2））S;
C） if（strcmp（s2,s1）>0） S; D） if（strcmp（s1,s2）>0）S;
（12） 有以下程序
main（）
{char str[][10]={"China","Beijing"},*p=str;
printf（"%s\n",p+10）;
}
程序运行后的输出结果是
A） China B） Bejing C） ng D） ing
（13） 有以下程序
main（）
{char s[]="ABCD",*p;
for（p=s+1;p }
程序运行后的输出结果是
A） ABCD B） A C） B D） BCD
BCD B C CD
CD C D D
D D
（14） 有以下程序
main（）
{ char s[]"Yes\n/No",*ps=s;
puts（ps+4）;
*（ps+4）=0;
puts（s）;
}
程序运行后的输出结果是（选项D中的第一行是空行）
A） n/No B） /No C） n/NO D）
Yes Yes Yes /No
/No /No Yes
（15） 有以下定义
#include
char a[10],*b=a;
不能给数组a输入字符串的语句是
A） gets（A） B） gets（a[0]） C） gets（&a[0]）; D） gets（B） ;
（16） 有以下程序
main（ ）
{ char *p[10]={“abc”,”aabdfg”,”dcdbe”,”abbd”,”cd”};
printf（“%d\n”,strlen（p[4]））;
}
执行后输出结果是
A） 2 B） 3 C） 4 D） 5
（17） 以下程序段中，不能正确赋字符串（编译时系统会提示错误）的是
A） char s[10]=”abcdefg”; B） char t[]=”abcdefg”,*s=t;
C） char s[10];s=”abcdefg”; D） char s[10];strcpy（s,”abcdefg”）;
（18） 下列选项中正确的语句组是
A） char s[8]; s={"Beijing"}; B） char *s; s={"Beijing"};
C） char s[8]; s="Beijing"; D） char *s; s="Beijing";
（19） 以下程序中函数scmp的功能是返回形参指针s1和 s2所指字符串中较小字符串的首地址
#include
#include
char *scmp（char *s1, char *s2）
{ if（ strcmp （s1, s2<0）
return（s1）;
else return（s2）;
}
main （）
{ int I; char string[20], str[3][20];
for（i=0;i<3;i++） gets（str[i]）;
strcpy（string,scmp（str[0],str[1]））;/*库函数strcpy对字符串进行复制*/
strcpy（string,scmp（string,str[2]））;
printf（"%s\n",string）;
}
运行时依次输入：abcd、abba和abc三个字符串，则输出结果为
A） abcd B） abba C） abc D） abca
（20） 有以下程序
#include
main（）
{ char str[][20]={"Hello","Beijing"}, *p=str;
printf（"%d\n",strlin（p+20））;
}
程序运行后的输出结果是
A） 0 B） 5 C） 7 D） 20
（21） 已定义以下函数
fun（char *p2, char *p1）
{ while（（*p2=*p1）!=‘\0’）{p1++;p2++; } }
函数的功能是
A） 将p1所指字符串复制到p2所指内存空间
B） 将p1 所指字符串的地址赋给指针 p2
C） 对p1和p2两个指针所指字符串进行比较
D） 检查p1和p2两个指针所指字符串中是否有‘\0’
（22） 有以下程序
main（）
{ char *s[]={"one","two","three"},*p;
p=s[1];
printf（"%c,%s\n",*（p+1）,s[0]）;
}
执行后输出结果是
A） n,two B） t,one C）w,one D） o,two
（23） 阅读以下函数
fun（char *s1,char *s2）
{ int i=0;
while（s1[i]==s2[i]&& s2[i]!=‘\0’）i++;
return（s1[i]== && s2{i}!==‘\0’）;
}
此函数的功能是
A） 将s2所指字符串赋给s1
B） 比较s1和s2所指字符串的大小，若s1比s2的大，函数值为1，否则函数值为0
C） 比较s1和s2所指字符串是否相等，若相等，函数值为1，否则函数值为0
D） 比较s1和s2所指字符串的长度，若s1比s2的长，函数值为1，否则函数值为0
（24） 有以下程序
main（）
{ char str[]="xyz",*ps=str;
while（*ps）ps++;
for（ps--;ps-str>=0;ps--） puts（ps）;
}
执行后的输出结果是
A） yz B） z C） z D） x
xyz yz yz xy
xyz xyz
（25） 有以下程序
#include
main（）
{ char *p=“abcde\Ofghjik\0”;
printf（“%d\n”,strlen（p））;
}
程序运行后的输出结果是
A） 12 B） 15 C） 6 D） 5
（26） 有以下程序
void ss（char *s,char t）
{ while（*s）
{ if（*s==t） *s=t-‘a’+’A’;
s++;
}
}
main（）
{ char str1[100]=“abcddfefdbd”,c=’d’;
ss（str1,c）; printf（“%s\n”,str1）;
}
程序运行后的输出结果是
A） ABCDDEFEDBD B） abcDDfefDbD
C） abcAAfefAbA D） Abcddfefdbd
（27） 以下程序的输出结果是
char cchar（char ch）
{
if（ch>=‘A’&&ch<=‘Z'） ch=ch-‘A'+‘a';
return ch;
}
main（）
{ char s[]="ABC+abc=defDEF",*p=s;
while（*p）
{ *p=cchar（*p）;
p++;
}
printf（"%s\n",s）;
}
A） abc+ABC=DEFdef B） abc+abc=defdef
C） abcaABCDEFdef D） abcabcdefdef
（28） 以下程序段的输出结果是
char s[]="\\141\141abc\t";
printf （"%d\n",strlen（s））;
A） 9 B） 12 C） 13 D） 14
（29） 以下程序的输出结果是
main（）
{ char cf[3][5]={"AAAA","BBB","CC"};
printf（"\"%s\"\n",ch[1]）;
}
A） "AAAA" B） "BBB" C） "BBBCC" D） "CC"
（30） 以下程序的输出结果是
#include
#include
main（）
{ char b1[8]="abcdefg",b2[8],*pb=b1+3;
while （--pb>=b1） strcpy（b2,pb）;
printf（"%d\n",strlen（b2））;
}
A） 8 B） 3 C） 1 D） 7
（31） 以下定义语句中，错误的是
A） int a[]={1,2}; B） char *a[3];
C） char s[10]=”test”; D） int n=5,a[n];
（32） 以下选项中，不能正确赋值的是
A） char s1[10];s1=“Ctest”;
B） char s2[]={‘C’, ‘t’, ‘e’, ‘s’, ‘t’};
C） char s3[20]=“Ctest”;
D） char *s4=“Ctest\n”
（33） 以下程序的输出结果是
A） ABCD B） ABCD C） EFG D） EFGH
FGH EFG JK IJKL
KL IJ O
M
main（）
{ char w[][10]={ “ABCD”,”EFGH”,”IJKL”,”MNOP”},k;
for（k=1;k<3;k++） printf（“%s\n”,w[k]）;
}
（34） 当执行下面的程序时，如果输入ABC，则输出结果是
A） ABC6789 B） ABC67 C） 12345ABC6 D） ABC456789
#include “stdio.h”
#include “string.h”
main（）
{ char ss[10]=“1,2,3,4,5”;
gets（ss）; strcat（ss, “6789”）; printf（“%s\n”,ss）;
}
（35） 有如下程序
main（）
{ char s[]=”ABCD”, *P;
for（p=s+l; p }
该程序的输出结果是
A） ABCD B） A C） B D） BCD
BCD B C CD
CD C D D
D D
（36） 有如下程序
main（）
{ char ch[2][5]={“6937”,”8254”},*p[2];
int i,j,s=0;
for（i=0;i<2;i++） p[i]=ch[i];
for（i=0;i<2;i++）
for（j=0;p[i][j]>’\0’;j+=2）
s=10*s+p[i][j]-‘0’;
printf（“%d\n”,s）;
}
该程序的输出结果是
A） 69825 B） 63825 C） 6385 D） 693825
（37） 设有数组定义: char array [ ]="China"; 则数组 array所占的空间为
A） 4个字节 B） 5个字节 C） 6个字节 D） 7个字节
（38） 设已有定义: char *st="how are you"; 下列程序段中正确的是
A） char a[11], *p; strcpy（p=a+1,&st[4]）;
B） char a[11]; strcpy（++a, st）;
C） char a[11]; strcpy（a, st）;
D） char a[], *p; strcpy（p=&a[1],st+2）;
（39） 下列程序执行后的输出结果是
A） you&ne B） you C） me D） err
mai（）
{ char arr[2][4];
strcpy（arr,"you"）; strcpy（arr[1],"me"）;
arr[0][3]='&';
printf（"%s \n",arr）;
}
（40） 执行下列程序时输入:123<空格>456<空格>789<回车>,输出结果是
A） 123,456,789 B） 1,456,789
C） 1,23,456,789 D） 1,23,456
main（）
{ char s[100]; int c, i;
scanf（"%c",&c）; scanf（"%d",&i）; scanf（"%s",s）;
printf（"%c,%d,%s \n",c,i,s）;
}
（41） 下列描述中不正确的是
A） 字符型数组中可以存放字符串
B） 可以对字符型数组进行整体输入、输出
C） 可以对整型数组进行整体输入、输出
D） 不能在赋值语句中通过赋值运算符"="对字符型数组进行整体赋值
（42） 以下程序的输出结果是
A） 123456780 B） 123 456 780 C） 12345678 D） 147
main（ ）
{ char ch[3][4]={"123"，"456"，"78"}， *p[3]； int i；
for（i=0；i<3；i++） p[i]=ch[i]；
for（i=0；i<3；i++） printf（"%s"，p[i]）；
}
（43） 以下程序的输出结果是
A）4 2 1 1 B） 0 0 0 8 C） 4 6 7 8 D） 8 8 8 8
main（ ）
{ char *s="12134211"； int v[4]={0，0，0，0}，k，i；
for（k=0；s[k]；k++）
{ switch（s[k]）
{ case '1'：i=0；
case '2'：i=1；
case '3'：i=2；
case '4'：i=3；
}
v[i]++；
}
for（k=0；k<4；k++） printf（"%d "，v[k]）；
}
（44） 以下程序的输出结果是
A） AfghdEFG B） Abfhd C） Afghd D） Afgd
#include
main（ ）
{ char *p1，*p2，str[50]="ABCDEFG"；
p1="abcd"； p2="efgh"；
strcpy（str+1，p2+1）； strcpy（str+3，p1+3）；
printf（"%s"，str）；
}
（45） 以下程序运行后,输出结果是
A） cde B） 字符c的ASCII码值 C） 字符c的地址 D） 出错
main（）
{ char *s="abcde";
s+=2;
printf（"%ld\n",s）;
}
（46） 下面能正确进行字符串赋值操作的语句是
A） char s[5]={"ABCDE"}; B） char s[5]={'A','B','C','D','E'};
C） char *s;s="ABCDEF"; D） char *s; scanf（"%s",s）;
（47） 以下程序运行后,如果从键盘上输入ABCDE<回车>,则输出结果为
A） 8 B） 7 C） 6 D） 5
#include
#include
func { int num=0;
while（*（str+num）!='\0'） num++;
return（num）;
}
main（）
{ char str[10],*p=str;
gets（p）; printf（"%d\n",func（p））;
}
（48） 下面程序运行的结果是
A） 2ba56 B） 6521 C） 6 D） 62
main（）
{ char ch[7]={65ab21"};
int i,s=0
for（i=0;ch[i]>='0' && ch[i]<='9';i+=2）
s=10*s+ch[i]-'0';
printf（"%d\n",s）;
}
（49） 运行下面的程序,如果从键盘上输入:
ab<回车>
c <回车>
def<回车>
则输出结果为
A） a B） a C） ab D） abcdef
b b c
c c d
d d
e
f
#include
#define N 6
main（）
{ char c[N];
int i=0;
for（ ;i for（ i=0;i }
（50） 以下程序运行后,输出结果是
A） 8 B） 7 C） 6 D） 5
#include
ss（char *s）
{ char *p=s;
while（*p） p++;
return（p-s）;
}
main（）
{ char *a="abded";
int i;
i=ss（a）;
printf（"%d\n",i）;
}
（51） 以下程序运行后,输出结果是
A） 6385 B） 22 C） 33 D） 693825
main（）
{ char ch[2][5]={'693","825"},*p[2];
int i,j,s=0;
for（i=0;i<2;i++） p[i]=ch[i];
for（i=0;i<2;i++）
for（j=0;p[i][j]='0' && p[i][j]<='9';j+=2）
s=10*s+p[i][j]-'0';
printf（"%d\n",s）;
}
（52） 以下程序运行后,输出结果是
A） 1234567 B） 7654321 C） 1711717 D） 7177171
#inchude
#inchude
fun（char *w, int n）
{ char t, *s1,*s2;
s1=w: s2=w+n-1;
while（s1 { t=*s1++;
*s1=*s2--;
*s2=t;
}
}
main（）
{ char *p;
p="1234567";
fun（p,strlen（p））;
puts（p）;
}
（53） 以下程序运行后,如果从键盘上输入:
book <回车>
book <空格><回车>
则输出的结果是
A） *8 B） #9 C） #6 D） *9
#include
main（）
{ char a1[80],a2[80],*s1=a1, *s2=a2;
gets（s1）; gets（s2）;
if（! strcmp（s1,s2）） printf（"*"）;
esle printf（"#"）;
printf（"%d/n",strlen（strcat（s1,s2）））;
}
（54） 给出以下定义:
char x[ ]="abcdefg";
char y[ ]={'a','b','c','d','e','f','g'};
则正确的叙述为
A） 数组X和数组Y等价 B） 数组x和数组Y的长度相同
C） 数组X的长度大于数组Y的长度 D） 数组X的长度小于数组Y的长度
（55） 有以下程序
main（）
{ char a[]="programming", b[]="language";
char *p1,*p2;
int i;
p1=a; p2=b;
for（i=0;i<7;i++）
if（*（p1+i）==*（p2+i）） printf（"％c",*（p1+i））;
}
输出结果是
A） gm B） rg C） or D） ga
（56） 若有以下定义:
char s[20]="programming",*ps=s;
则不能代表字符o的表达式是
A） ps+2 B）s[2] C） ps[2] D）ps+=2,*ps
（57） 若有以下定义和语句:
char *s1="12345",*s2="1234";
printf（"%d\n",strlen（strcpy（s1,s2）））;
则输出结果是_____
A） 4 B）5 C）9 D）10
（58） 下面程序的输出是_____
main（）
{ char *s="121";
int k=0, a=0, b=0;
do {k++;
if（k%2==0） {a=a+s[k]-'0';
continue;}
b=b+s[k]-'0';
a=a+s[k]-'0';
}
while （s[k+1]）;
printf（"k=%d a=%d b=%d\n",k,a,b）;
A）k=3 a=2 b=3 B）k=3 a=3 b=2 C）k=2 a=3 b=2 D）k=2 a=2 b=3
（59） 以下程序输出的结果是
#include
#include
main（）
{ char w[][10]={"ABCD","EFGH","IJKL","MNOP"},K;
for （k=1;k<3;k++）
printf（"%s\n",&w[k][k]）;
}
A）ABCD B）ABCD
FGH EFG
KL IJ
M
C）EFG D）FGH
JK KL
（60） 若有以下程序片段:
char str[]="ab\n\012\\\"";
printf（%d",strlen（str））;
上面程序片段的输出结果是_____
A）3 B）4 C）6 D）12
（61） 函数调用:strcat（strcpy（str1,str2）,str3）的功能是
A） 将串str1复制到串str2中后再连接到串str3之后
B） 将串str1连接到串str2之后再复制到串str3之后
C） 将串str2复制到串str1中后再将串str3连接到串str1之后
D） 将串str2连接到串str1之后再将串str1复制到串str3中
（62） 不能把字符串:Hello!赋给数组b的语句是
A） char b[10]={'H','e','l','l','o','!'};
B） char b[10];b="Hello!";
C） char b[10];strcpy（b,"Hello!"）;
D） char b[10]="Hello!";
（63） 下面程序的输出是
main（）
{ int x=3,y=6,a=0;
while（x++!=（y+=o1））
{ a+o=1;
if（y
#include
main（）
{ char ss[10]="12345";
strcat（ss,"6789"）;
gets（ss）;printf（"%s\n",ss）;
}
A） ABC B） ABC9 C） 123456ABC D） ABC456789
（64） 下面程序的输出是
main（）
{ char *a="12134211";
int v1=0,v2=0,v3=0,v4=0,k;
for（k=0;s[k];k++）
switch（s[k]）
{ default:v4++;
case '1': v1++;
case '3': v3++;
case '2': v2++; }
printf（"v1=%d,v2=%d,v3=%d,v4=%d\n",v1,v2,v3,v4）; }
A） v1=4,v2=2,v3=1,v4=1 B） v1=4,v2=9,v3=3,v4=1
C） v1=5,v2=8,v3=6,v4=1 D） v1=8,v2=8,v3=8,v4=8
（65） 当执行下面程序且输入：ABC时，输出的结果是
#include
#include
main（）
{ char ss[10]="12345";
gets（ss）;printf（"%s\n",ss）; }
A） ABC B） ABC9 C） 123456ABC D） ABC456789
（66） 下面程序的输出是
#include
main（）
{ char*a="abcdefgh";
fun（a）;puts（a）; }
fun （char * s）
{ int x=0,y;char c;
for（y=strlen（s）-1;x A）abcdefgh B）hgfdecba C）dcbahgfe D）hgfedcba
（67） 下述对C语言字符数组的描术中错误的是
A） 字符数组可以存放字符串
B） 字符数组中的字符串可以整体输入、输出
C） 可以在赋值语句中通过赋值运算符"="对字符数组整体赋值
D） 不可以用关系运算符对字符数组中的字符串进行比较
（68） 设有如下函数定义:
int f（char *s）
{ char *p=s;
while（*p!='\0'） p++;
return（p-s）; }
如果在主程序中用下面的语句调用上述函数,则输出结果为
printf（"%d\n",f（"goodbey!"））;
A） 3 B） 6 C） 8 D） 0
（69） 设有如下定义: char *aa[2]={"abcd","ABCD"}; 则以下就法中正确的是
A） aa数组成元素的值分别是"abcd"和ABCD"
B） aa是指针变量,它指向含有两个数组元素的字符型一维数组
C） aa数组的两个元素分别存放的是含有4个字符的一维字符数组的首地址
D） aa数组的两个元素中各自存放了字符'a'和'A'的地址
（70） 下列程序的输出结果是
main（ ）
{ char*p1,*p2,str[50]="xyz";
p1="abcd";
p2="ABCD";
strcpy（str+2,strcat（p1+2,p2+1）;
printf）"%s",str）; }
A） xyabcAB B） abcABz C） ABabcz D） xycdBCD
（71） 下列程序的输出结果是
main（ ）
{ char ch[2][5]={"6934,"8254"},*p[2];
int i,j,s=0;
for（i=0;i<2;i + +） p[i]=ch[i];
for（i=0;i<2;i + +）
for（j=0;p[i][j]>'\0'&&p[i][j]<='9';j+=2） s=10*s+p[i][j]-'0';
printf（"%d\n",s）;
A） 6385 B） 69825 C） 63825 D） 693825
72） 以下程序的输出结果是
#include"ctype.h"
space （char *str）
{ int i,t;char ts[81];
for（i=0,t=0;str[i]!='\0';i+=2）
if（! isspace（*str+i）&&（*（str+i）!='a'））
ts[t++]=toupper（str[i]）;
ts[t]='\0';
strcpy（str,ts）; }
mian（ ）
{ char s[81]={"a b c d e f g"};
space（s）;
puts（s）; }
A） abcdeg B） bcde C） ABCDE D） BCDE
（73） 下面函数的功能是
A） 求字符串的长度 B） 比较两个字符串的大小
C） 将字符串x复制到字符串y D） 将字符串x连接到字符串y后面
int funl（char * x）
{ char * y=x;
while（*y++）;
return（y-x-1）;}
（74） 下面程序的输出是
A） xyzabcABC B） zabcABC C） yzabcABC D） xyabcABC
#include
#include
main（）
{ char *p1="abc",*p2="ABC",str[50]="xyz";
strcpy（str+2,strcat（p1,p2））;
printf（"%s\n", str）;}
（75） 下面程序的输出是
A） ABCD B） A C） D D） ABCD
BCD B C ABC
CD C B AB
D D A A
char s[]="ABCD";
main（）
{ char *p;
for（p=s; p printf（"%s\n,p）;}
（76） 下面各语句行中，能正确进行赋字符串操作的语句行是
A） char st[4][5]={"ABCDE"}; B） char s[5]={'A','B','C','D','E'};
C） char *s; s="ABCDE"; D） char *s; scanf（"%s",s）;
（77） 请读程序：
#include
f（char *s）
{ char *p=s;
while（ *p!='\0'） p++;
return（p-s）;
}
main（）
{ printf（"%d\n",f（"ABCDEF"））;}
上面程序的输出结果是
A） 3 B） 6 C） 8 D） 0
（78） 请读程序片段：
char str[]="ABCD", *p=str;
printf（"%d\n",*（p+4））;
上面程序的输出结果是
A） 68 B） 0 C） 字符"D"的地址 D） 不确定的值
（79） 请读程序片段（字符串内没有空格）:
printf（"%d\n",strlen（"ATS\n012\1\\"））;
上面程序片段的输出结果是
A） 11 B） 10 C） 9 D） 8
（80） 请读程序:
#include
#include
main（）
{ char*s1="AbCdEf", *s2="aB";
s1++; s2++;
printf（"%d\n",strcmp（s1,s2））;
}
上面程序的输出结果是
A） 正数 B） 负数 C） 零 D） 不确定的值
（81） 请读程序:
#include
char fun（char *c）
{ if（ *c<='Z' && *c>='A'） *c-='A'-'a';
return *c;
}
main（）
{ char s[81], *p=s;
gets（s）;
while（*p）
{*p=fun（p）; putchar（*p）; p++;}
putchar（'\n'）;
}
若运行时从键盘上输入OPEN THE DOOR（表示回车），则上面程序的输出结果是
A） oPEN tHE door B） open the door C） OPEN THE DOOR D） Open The Door
（82） 请读程序:
#include
#include
void fun（ char *s）
{ char a[10];
strcpy（ a, "STRING"）;
s=a;
}
main（）
{ char *p;
fun（p）;
x=f（a, 3）;
printf（"%s\n",p）;
}
上面程序的输出结果是（└┘表示空格）
A） STRING└┘└┘└┘└┘ B） STRING
C） STRING└┘└┘└┘ D） 不确定的值
（83） 请读程序:
#include
#include
void fun（ char *w, int m）
{ char s, *p1, *p2;
p1=w; p2=w+m-1;
while （p1 { s=*p1++; *p1=*p2--; *p2=s;}
}
main（）
{ char a[]="ABCDEFG";
fun（ a, strlen（a））;
puts（a）;
}
上面程序的输出结果是
A） GFEDCBA B） AGADAGA C） AGAAGAG D） GAGGAGA
（84） 请选出以下语句的输出结果
printf（"%d\n",strlen（"\t\"\065\xff\n"））;
A） 5 B） 14 C） 8 D） 输出项不合法，无正常输出
（85） 设有如下的程序段:
char str[ ]="Hello";
char *ptr;
ptr=str;
执行上面的程序段后，*（ptr+5）的值为
A） 'o' B） '\0' C） 不确定的值 D） 'o'的地址
（86） 设有
static char str[ ]="Beijing";
则执行
printf（"%d\n", strlen（strcpy（str,"China"）））;
后的输出结果为
A） 5 B） 7 C） 12 D） 14
（87） 请选出以下程序段的输出结果
#include
main（）
{ char sl[10], s2[10], s3[10], s4[10];
scanf（"%s%s",s1,s2）; gets（s3）; gets（s4）;
puts（s1）; puts（s2）; puts（s3）; puts（s4）;
}
输入数据如下:（此处代表回车符）
aaaa bbbb
cccc dddd
A） aaaa B） aaaa C） aaaa D） aaaa bbbb
bbbb bbbb bbbb cccc
cccc cccc dddd dddd
cccc dddd dddd eeee
（88） 指针s所指字符串的长度为 【88】 。
char *s="\\"Name\\Address\n";
A） 19 B） 15 C） 18 D） 说明不合法
（89） 以下程序的输出结果是 【89】 。
# include
# include
main（）
{ char str[12]={'s','t','r','i','n','g'};
printf（"%d\n",strlen（str））; }
A） 6 B） 7 C） 11 D） 12
（90） 以下程序的输出结果为 【90】 。
main（）
{ char *alpha[6]={"ABCD","IJKL","MNOP","QRST","UVWX"};
char **p; int i;
p=alpha;
for（i=0;i<4;i + + ） printf（"%s",p[i]）; printf（"\n"）; }
A） ABCDEFGHIJKL B） ABCD C） ABCDEFGHIJKLMNOP D） AEIM
（91） 设有以下语句：
char str[4][12]={"aaa","bbbb","ccccc","dddddd"},
*strp[4];
int i;
for（i=0;i<4;i + + ）strp[i]=str[i];
【91】 不是对字符串的正确引用，其中0≤k<4。
A） strp B） str[k] C） strp[k] D） *strp
（92） 设有以下语句：
char str1[]="string",str2[8],*str3,*str4="string";
则 【92】 不是对库函数strcpy的正确调用，此库函数用业复制字符串。
A） strcpy（str1,"HELLO1"）; B） strcpy（str2,"HELLO2"）;
C） strcpy（str3,"HELLO3"）; D） strcpy（str4,"HELLO4"）;
二、填空题：
（1）以下函数sstrcat（）的功能是实现字符串的连接，即将t所指字符串复制到s所指字符串的尾部。例如：s所指字符串为abcd，t所指字符串为efgh，函数调用后s所指字符串为abcdefgh。请填空。
# include
void sstrcat（char *s, char *t）
{ int n;
n= strlen（s）;
while （*（s+n）= 【1】 ）{s++; t++;}
}
（2）以下程序运行后的输出结果是 【2】 。
#include
char *ss（char *s）
{ char *p, t;
p=s+1; t=*s;
while（*p） { *（p-1） = *p; p++;}
*（p-1）=t;
return s;
}
main（）
{ char *p, str[10]="abcdefgh";
p = ss（str） ;
printf（"%s\n",p）;
}
（3）以下程序运行后的输出结果是 【3】
#include "string.h"
void fun（char *s,int p,int k）
{ int i;
for（i=p;i s[i]=s[i+2];
}
main（）
{ char s[]="abcdefg";
fun（s,3,strlen（s））;
puts（s）;
}
（4）以下程序运行后的输出结果是【4】
#include "string.h"
main（）
{
char ch[]="abc",x[3][4]; int i;
for（i=0;i<3;i++） strcpy（x[i],ch）;
for（i=0;i<3;i++） printf（"%s",&x[i][i]）;
printf（"\n"）;
}
（5）以下程序中函数huiwen的功能是检查一个字符串是否是回文,当字符串是回文时,函数返回字符串:yes
yes!,否则函数返回字符串:no!,并在主函数中输出.所谓回文即正向与反向的拼写都一样,例如:adgda.请填空.
#include "string.h"
char *huiwen（char *str）
{
char *p1,*p2; int i,t=0;
p1=str; p2= ①
for（i=0;i<=strlen（str）/2;i++）
if（*p1++!=*p2--）
{ t=1; break; }
if（ ②） return （"yes!"）;
else return （"no!"）;
}
main（）
{
char str[50];
printf（"Input:"）; scanf（"%s",str）;
printf（"%s\n", ③ ）;
}
【5】
【6】
【7】
（6） 以下程序运行后的输出结果是 【8】 。
main （）
{ char a[]="Language",b[]="Programe";
char *p1,*p2; int k;
p1=a; p2=b;
for（k=0;k<=7;k++）
if（*p1+k）==*（p2+k）} printf（"%c",*（p1+k））_;
]
（7） 以下程序运行后的输出结果是 【9】 。
main（）
{ char a[]="123456789",*p; int i=0;
p=a;
while（*p）
{ if（i%2==0） *p='*';
p++;i++;
}
puts（a）;
}
（8） 以下sstrcpy（ ）函数实现字符串复制，即将t所指字符串复制到s所指向内存空间中，形成一个新的字符串s。请填空。
void sstrcpy（char *s,char *t）
{ while（*s++=【10】）；}
main（ ）
{ char str1[100],str2[]=”abcdefgh”;
sstrcpy（str1,str2）;
printf（“%s\n”,str1）;
}
（9） 下列程序的运行结果是：【11】
#include
char *ss（char *s）
{ return s+strlen（s）/2;}
main（ ）
{ char *p,*str=”abcdefgh”;
p=ss（str）; printf（“%s\n”,p）;
}
（10） 以下程序运行后输入：3,abcde＜回车＞，则输出结果是 【12】
#include
move（char *str, int n）
{ char temp ; int i;
temp=str[n-1];
for（i=n-1; i>0;i--） str[i]=str[i-1];
str[0]=temp;
}
main（）
{ char s[50]; int n, i, z;
scanf（"%d,%s",&n, s）;
z=strlen（s）;
for（i=1; i<=n; i++） move（s,z）;
printf（"%s\n",s）;
}
（11） 以下程序的功能是将字符串s中的数字字符放入d数组中，最后输出d中的字符串。例如，输入字符串：abc123edf456gh，执行程序后输出：123456。请填空。
#include
#include
main（）
{ char s[80], d[80]; int i, j;
gets（s）;
for（i=j=0; s[i]!=‘\0’; i++）
if（ 【13】 ） { d[j]=s[i]; j++;}
d[j]=‘\0’;
puts（d）;
}
（12） 以下函数的功能是删除字符串s中的所有数字字符。请填空。
void dele（char *s）
{ int n=0,i;
for（i=0,s[i];i++）
if（【14】）
s[n++]=s[i];
s[n]=【15】;
}
（13） 函数sstrcmp（）的功能是对两个字符串进行比较。当s所指字符串和t所指字符串相等时，返回值为0；当s所指字符串大于t所指字符串时，返回值大于0；当s所指字符串小于t所指字符串时，返回值小于0（功能等同于库函数strcmp（））。请填空。
#include
int sstrcmp（char *s,char *t）
{ while（*s&&*t&& *s== [16] ）
{ s++;t++;}
return [17] ;
}
（14） 以下程序的输出结果是【18】 。
main（）
{ char *p="abcdefgh",*r;
long *q;
q=（long*）p;
q++;
r=（char*）q;
printf（"%s\n",r）;
}
（15） 以下程序的输出结果是【19】 。
main（）
{ char s[]="abcdef";
s[3]=‘\0';
printf（"%s\n",s）;
}
（16） mystrlen函数的功能是计算str所指字符串的长度,并作为函数值返回。请填空。
int mystrlen（char *str）
{ int i;
for（i=0; 【20】!=‘\0';i++）;
return（【21】）;
}
（17） 以下程序运行后的输出结果是 【22】 。
main（）
{ char s[ ]=“9876”,*p;
for （ p=s ; p }
（18） 若有定义语句： char s[100],d[100]; int j=0, i=0;，且s中已赋字符串，请填空以实现字符串拷贝。（注：不得使用逗号表达式）
while（[i]）{ d[j]= 【23】;j++;}
d[j]=0;
（19） 下列程序段的输出结果是 【24】 。
main（）
{ char b[]=”Hello,you”;
b[5]=0;
printf（“%s \n”, b ）;
}
（20） 以下函数把b字符串连接到a字符串的后面，并返回a中新字符串的长度。请填空。
Strcen（char a[], char b[]）
{ int num=0,n=0;
while（*（a+num）!= [25] ） num++;
while（b[n]）{*（a+num）=b[n]; num++; [26] ;}
return（num）;
}
（21） 下面程序的功能是:将字符数组a中下标值为偶数的元素从小到大排列,其它元素不变。请填空。
#include
#include
main（）
{ char a[]="clanguage",t;
int i, j, k;
k=strlen（a）;
for（i=0; i<=k-2; i+=2）
for（j=i+2; j<=k; [27] ）
if（ [28] ）
{ t=a[i]; a[i]=a[j]; a[j]=t; }
puts（a）;
printf（"\n"）;
}
（22） 以下程序的功能是:将无符号八进制数字构成的字符串转换为十进制整数。例如,输入的字符串为:556,则输出十进制整数366。请填空。
#include
main（）
{ char *p, s[6];
int n;
p=s;
gets（p）;
n=*p-'0';
while（ [29] !='\0'）n=n*8+*p-'0';
printf（"%d \n",n）;
}
（23） 下列程序的输出结果是 【30】 。
#include
main（ ）
{ char b[30]，*chp；
strcpy（&b[0]，"CH"）；
strcpy（&b[1]，"DEF"）；
strcpy（&b[2]，"ABC"）；
printf（"%s \n"，b）；
}
（24） 下列程序中字符串中各单词之间有一个空格，则程序的输出结果是 【31】 。
#include
main（ ）
{ char strl[]="How do you do"， *p1=strl；
strcpy（strl+strlen（strl）/2，"es she"）；
printf（"%s \n"，pl）；
}
（25） 若想通过以下输入语句使a中存放字符串1234,b中存放字符5,则输入数据的形式应该是【32】
:
.
char a[10],b;
scanf（"a=%s b=%c",a,&b）;
:
.
（26） 下面程序的输出结果是 【33】
char b[]="ＡＢＣＤ";
main（）
{ char *chp;
for（chp=b; *chp: chp+=2） printf（"%s",chp）;
printf（"\n"）;
（27） 以下程序输出的是 【34】
main（ ）
{ int i=3, j=2;
char *a="ＤＣＢＡ";
printf（"%c%c\n",a[i],a[j]）;
}
（28） 函数fun的功能是:使一个字符串按逆序存放,请填空
void fun （char str[]）
{ char m; int i,j;
for（i=0,j=strlen（str）;i<【35】;i++,j--）
{ m=str[i];
str[i]=【36】;
str[j-1]=m;
}
printf（"%s\n",str）;
}
（29） 以下程序的功能是:从键盘上输入一行字符,存入一个字符数组中,然后输出该字符串,请填空。
#include"ctype.h"
#include"stdio.h"
main（）
{ char str[81],*sptr;
int i;
for（i=0;i<80;i++）
{ str[i]=getchar（）;
if（str[i]=='\n'） break;
}
str[i]=【37】;
sptr=str;
while（*sptr） putchar（*sptr【38】）;
}
（30） 以下程序用来对从键盘上输入的两个字符串进行比较,然后输出两个字符串中第一个不相同字符的ASCII码之差。例如:输入的两个字符串分别为abcdef和abceef,则输出为-1。请填空。
#include
main（）
{ char str[100],str2[100],c;
int i,s;
printf（"\n input string 1:\n"）; gest（str1）;
printf（"\n input string 2:\n"）; gest（str2）;
i=0;
while（（strl[i]==str2[i]&&（str1[i]!=【39】））
i++;
s=【40】;
printf（"%d\n",s）;
}
（31） 以下程序可以把从键盘上输入的十进制数（long型）以二到十六进制形式输出,请填空。
#include.
main（）
{ char b[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C'
,'D','E','F'};
int c[64],d,i=0,base;
long n;
printf（"enter a number:\n"）; scanf（"%ld",&n）;
printf（"enter new base:\n"）; scanf（"%d",&base）;
do
{ c[i]=【41】;
i++; n=n/base;
} while（n!=0）;
printf（"transmite new base:\n"）;
for（--i;i>=0;--i）
{ d=c[i];
printf（"%c",b【42】;
}
}
（32） 函数mycmp （char*s,chat *t）的功能是比较字符串s和t的大小，当s等于t 时返回0，否则返回s和t的第一个不同字符的ASCOII码的差值，即当s>t时返回正值， 当s等于t 时返回0,否则返回s和t的第一个不同字符的ASCOII码的差值,即当s>t时返回正值, 当s mycmp（char *s,char *t）
{ while（*s==*t）
{if（*s=='\0'） return 0;
++s; ++t;}
return （【43】）; }
（33） 下列程序的输出结果是【44】
main（） { char b[]="ABCDEFG";
char *chp=&b[7]; while（--chp>&b[0]） putchar（*chp）;
putchar（'\n'）; }
（34） 阅读程序:
#include "string.h"
#include "stdio.h"
strle（char a[],char b[]）
{ int num=0,n=0;
while（*（a+num）!='\0'）,num++;
while（b[n]）{ *（a+num）=b[n];num++;n++;}
return （num）;}
main（）
{ char str1[81],str2[81],*p1=str1,*p2=str2;
gets（p1）; gets（p2）;
printf（"%d\n",strle（p1,p2））; }
运行上面程序,如果从键盘上输入字符串qwerty和字符串abcd则程序的输出结果是 【45】 。
（35） 阅读程序:
main（）
{ char str1[]="how do you do" ,str2[10];
char *p1=str1,*p2=str2;
scanf（"%s",p2）; printf（"%s",p2）; printf（"%s\n",p1）; }
运行上面的程序,输入字符串HOW DO YOU DO 则程序的输出结果是【46】 。
（36） 已知函数isalpha（ch）的功能是判断自变量ch是否是字母，若是，函数值为1，否则为0。下面程序的输出是 【47】 。
#include
#include
void fun4（ char str[]）
{ int i,j;
for（i=0, j=0; str[i]; i++）
if（isalpha（str[i]）） str[j++]=str[i];
str[j]='\0';}
main（）
{ char ss[80]="It is!";
fun4（ss）;
printf（ '%s\n", ss）;}
（37） 下面invert函数的功能是将一个字符串str的内容颠倒过来。请填空。
#include
void invert（char str[]）
{ int i,j, 【48】 ;
for（i=0,j=strlen（str） 【49】 ; i { k=str[i]; str[i]=str[j]; str[j]=k;}
}
（38） 下面程序的输出结果是 【50】 。
#include
main（）
{ static char b[]="Goodbye";
char *chp=&b[7];
while（ --chp >=&b[0]） putchar（ *chp）;
putchar（'\n'）;
}
（39） 下面程序的输出结果是 【51】 。
#include
void fun（ char *a1, char *a2, int n）
{ int k;
for（ k=0; k a2[k]=（ a1[k]-'A'-3+26）&+'A';
a2[n]='\0';
}
main（）
{ char s1[5]="ABCD", s2[5];
fun（ s1, s2, 4）;
puts（ s2）;
}
（40） 下面程序的输出结果是 【52】 。
#include
main（）
{ char *p[]={ "BOOL", "OPK", "H", "SP"};
int i;
for（i=3; i>=0; i--,i--） printf（ "%c", *p[i]）;
printf（"\n"）;
}
（41） 设有下列程序:
#include
#include
main（）
{ int i;
char str[10], temp[10];
gets（temp）;
for （i=0; i<4; i++）
{ gets（str）;
if （strcmp（temp,str）<0） strcpy（temp,str）;
}
printf（"%s\n",temp）;
}
上述程序运行后，如果从键盘上输入（在此代表回车符）:
C++
BASIC
QuickC
Ada
Pascal
则程序的输出结果是 【53】 。
答案：
一、选择题：
1） A 2） B 3） D 4） B 5） B 6） C 7） D 8） A 9） D 10） A
11） D 12） B 13） D 14） B 15） B 16） A 17） C 18） D 19） B 20） C
21） A 22） C 23） C 24） C 25） D 26） B 27） B 28） A 29） B 30） D
31） D 32） A 33） D 34） A 35） D 36） C 37） C 38） A 39） A 40） D
41） C 42） C 43） B 44） D 45） C 46） C 47） D 48） C 49） C 50） D
51） A 52） C 53） B 54） C 55） D 56） A 57） A 58） C 59） D 60） C
61） C 62） B 63） D 64） C 65） A 66） D 67） C 68） C 69） D 70） D
71） A 72） D 73） A 74） D 75） A 76） C 77） B 78） B 79） C 80） A
81） B 82） D 83） C 84） A 85） B 86） A 87） A 88） B 89） A 90） C
91） A 92） C
二、填空题：
（1） *t
（2） bcdefgha
（3） abcfg
（4） abcbcc
（5） str+strlen（str）-1
（6） t==0或!t
（7） huiwen（str）
（8） gae
（9） *2*4*6*8*
（10） *t++
（11） efgh
（12） cdeab
（13） s[i]>='0' && s[i]< ='9'
（14） s[i]<'0'||s[i]>'9' 或 !（s[i]>='0'&&s[i]<='9'）
（15） '\0'或 0 或 NULL
（16） *t 或 t[0]
（17） *s-*t 或 *s-t[0] 或 s[0]-*t 或 s[0]-t[0]
（18） efgh
（19） abc
（20） *（str+i）str[i]
（21） i
（22） 9876 876
（23） s[i++]
（24） Hello
（25） '\0'或0
（26） n++或n+=1或n=n+1
（27） j+=2
（28） a[i]>a[j]
（29） *（++p）
（30） CDABC
（31） How des she
（32） a=1234 b=5 A或a=1234b=5
（33） ABCDCD
（34） AB
（35） strlen（str ）/2
（36） str[j-1]或*（str+j-1）
（37） '\0' 或0
（38） ++
（39） '\0'或0
（40） strl[i]-str2[i]
（41） nºse
（42） [d]
（43） *s=*t
（44） GFEDCB
（45） 10
（46） HOW how do you do （说明:HOW 和how之间有无空格均可）
（47） It is
（48） k
（49） -1
（50） eybdooG
（51） XYZA
（52） SO
（53） QuickC
|
