1.1、有以下程序
int main()
{ char a[7]="a0\0a0\0";int i,j;
i=sizeof(a); j=strlen(a);
printf("%d %d\n",i,j);
} //strlen求出字符串的长度,其实是字符串中字符的个数,不包括\0
程序运行后的输出结果是 C
A)2 2
B)7 6
C)7 2 // a 0
D)6 2
解析:sizeof求的是字符数组的内存大小,给字符数组申请多大的内存,sizeof求得的值就是多大,所以是7,strlen求出字符串的长度,是字符串中字符的个数,遇到\0就截止,所以只会计算a0\0这点的字符串的长度,为2
1.2、以下能正确定义一维数组的选项是 BC
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";
解析:int a[5]={0,1,2,3,4,5};初初始化一个大小为5的整数数组,但提供了6个初始值。
int a[5]="0123"整数数组不能接受字符串作为初始值。
1.3、已有定义:char a[]="xyz",b[]={'x','y','z'};,以下叙述中正确的是 C
A)数组a和b的长度相同
B)a数组长度小于b数组长度
C)a数组长度大于b数组长度
D)上述说法都不对
解析:字符串数组(会在末尾自动添加一个空字符'\0'作为字符串的结束标志。所以,数组的实际长度会比初始化的字符多一个。
1.4、以下语句或语句组中,能正确进行字符串赋值的是 D
A)char *sp; *sp="right!";
B)char s[10]; s="right!";
C)char s[10]; *s="right!";
D)char *sp="right!";
解析:char *sp; *sp="right!";:sp
是一个未初始化的指针,"right!"
是一个字符串字面量,它不能被直接赋值给一个字符
char s[10]; s="right!";数组名 s
是一个指向数组首元素的常量指针,不能被赋值
char s[10]; *s="right!";*s
表示数组 s
的第一个元素,它是一个字符。你不能将一个字符串字面量 "right!"
赋值给一个字符
1.5、有以下程序
main()
{
char s[]="159",*p;
p=s;
printf("%c",*p++);
printf("%c",*p++);
}
程序运行后的输出结果是 A
A)15
B)16
C)12
D)59
解析:第一次调用printf("%c",*p++);
,*p
的值是s[0]
,即'1'
,所以打印出'1'
,然后p
自增1,指向s[1]
。第二次调用printf("%c",*p++);
,*p
的值是s[1]
,即'5'
,所以打印出'5'
,然后p
自增1,指向s[2]
。
1.6、以下程序的输出结果是( A )。
main()
{ char s1[20]=“abc”,s2[20]=“123”;
if(strcmp(s1,s2)>0) printf(“%s\n”,s1)); //strcmp 比较字符串大小
else printf(“%s\n”,s2);
}
(A) abc (B) 123 (C) abc123 (D) 123abc
解析:s1
是 "abc",s2
是 "123"。,"abc" 在 "123" 之后,因此 strcmp(s1, s2)
的返回值是一个正值。因此程序会执行 printf("%s\n", s1);
,输出 s1
的值,即 "abc"。
1.7、有以下程序
#include<sthio.h>
int main()
{ char a[20],b[20],c[20];
scanf(“%s%s”,a,b);
gets(c);
printf(”%s,%s,%s\n”,a,b,c);
}
程序运行时从第一行开始输入 this is a cat!<回车>,则输出结果是 D
A) this, is, a B) this is, a , cat!
C) this is a, cat! D) this, is, a cat!
解析:scanf("%s %s", a, b);
会读取第一个空白字符之前的所有字符,并将它们存储在 a
中。然后它会跳过空白字符并读取下一个空白字符之前的所有字符,将它们存储在 b
中。因此,a
将包含 "this",b
将包含 "is"。gets(c); 会读取一行输入,并将其存储在 c
中。因此,c
将包含 "a cat!"。
1.8、有以下程序
#include<stdio.h>
#include<string.h>
main()
{ char a[5][10]={"china","beijing","you","tiananmen","welcome”);
int i,j;char t[10];
for(i=0;i<4;i++)
{
for(j=i+1;j<5;j++)
if(strcmp(a[i],a[j])>0)
{ strcpy(t,a[i]);strcpy(a[i],a[j]);strcpy(a[j],t);}
}
puts(a[3]);
}
其输出结果是 C
A)Beijing B)china C)welcome D)tiananmen
解析:使用了冒泡排序算法,通过比较相邻的字符串并交换它们来实现排序,排序后的数组:{"beijing","china" ,"tiananmen" ,"welcome" ,"you"}所以a[3]是welcome
1.9、有以下程序
#include<stdio.h>
int main()
{char ch [3][5]={"AAAA","BBB","CC");
printf ("%s\n",ch[1]);
}
程序运行后的输出结果是( D )。
A)AAAA B)CC C)BBBCC D)BBB
解析:数组ch
是一个3x5的字符数组,其中存储了三个字符串:"AAAA", "BBB", 和 "CC"。ch[1]
表示数组中的第二个字符串,即"BBB"
1.10、有以下程序(strcat 函数用以连接两个字符串)
#include <stdio.h>
#include <string.h>
int main()
{ char a[20]=”ABCD\0EFG\0”, b[ ]=”IJK”;
strcat(a,b); printf(“%s\n”,a);
}
程序运行后的输出结果是 B
A)ABCDE\OFG\OIJK B)ABCDIJK
C)IJK D)EFGIJK
解析:字符串 a
中间有一个'\0',它标志着字符串的结束。字符串 a
的声明长度为 20,但实际有效的字符串内容只到第一个 \0
,即 "ABCD"。字符串 b
被初始化为 "IJK",所以结果为ABCDIJK
1.11有以下程序段
char name[20];
int num;
scanf("name=%s num=%d",name,&num);
当执行上述程序段,并从键盘输入:name=Lili num=1001<回车>后,name 的值为 A
A)Lili B)name=Lili C)Lili num= D)name=Lili num=1001
解析:scanf会按照格式字符串的要求解析这个输入。它会跳过"name="部分,然后读取紧随其后的字符串"Lili",并将其存储在
name数组中
1.12 有以下程序
#include
#include main()
{ char str[ ][20]={“One*World”, “One*Dream!”},*p=str[1];
printf(“%d,”,strlen(p)); printf(“%s\n”,p);
}
程序运行后的输出结果是 C
A)9,One*World B)9,One*Dream!
C)10,One*Dream! D)10,One*World
解析:str
是一个二维字符数组,包含两个字符串:"OneWorld" 和 "OneDream!"。p
是一个字符指针,指向 str
数组中的第二个字符串 "One*Dream!"。strlen(p)
会计算 p
所指向的字符串的长度,不包括末尾的空字符('\0')。第一个 printf
会输出字符串 "One*Dream!" 的长度。第二个 printf
会输出字符串 "One*Dream!" 本身。
2、填空题
2.1、以下程序运行后的输出结果是 abcbcc
#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");
}
解析:x[0]
的内容为 "abc"。
x[1]
的内容为 "abc"。
x[2]
的内容为 "abc"。
接下来,printf
语句从 x[i][i]
开始打印:对于 i=0
,printf
从 x[0][0]
开始打印,输出 "abc"
对于 i=1
,printf
从 x[1][1]
开始打印,输出 "bc"
。对于 i=2
,printf
从 x[2][2]
开始打印,"c"
2.2、 以下程序的运行结果是 string s:I like it. string t:I like it.you? How are you
main( )
{ char s[20]=“I like it.” , t[20]=“Are you? How are you”, c[20] ;
int i=0;
while(s[++i]!=‘\0’)
t[i]=s[i];
t[i]=0;
printf(“string s:%s\n”,s);
printf(“string t:%s\n”,t);
}
解析:字符串s
初始化为"I like it."
。字符串t
初始化为"Are you? How are you"
。字符串c
虽然被声明了,但在程序中并没有使用。变量i
初始化为0,用作字符串复制的索引。while
循环将s
字符串的内容复制到t
字符串中,从s
的第一个字符开始,直到遇到s
的结束符\0
为止。循环结束后,t
字符串的当前位置(即i
所指向的位置)也被设置为\0
,以确保t
是一个合法的C字符串。最后,程序输出两个字符串s
和t
的内容。由于s
和t
的初始值不同,并且t
的前几个字符会被s
的内容覆盖,因此输出结果将是:
string s:I like it.
string t:I like it.you? How are you
2.3、下面程序运行的结果为 30 10 30 n Learning 。
int main()
{
int i=10, a[]={10,20,30,15}, *p1;
char *b=”Learning”, **p2=&b;
p1=&i;
printf(“%4d”,*p1+20);
for(p1=a;p1<a+4;p1+=2)
printf(“%4d”,*p1);
printf(“\n%c\t%s\n”,*(b+4),*p2);
}
解析:int i = 10;
定义了一个整型变量 i
并初始化为 10。char *b = "Learning";
定义了一个字符指针 b
并指向字符串 "Learning" 的第一个字符 'L'。**p2 = &b;
定义了一个指向字符指针的指针 p2
并使其指向 b
。p1 = &i;
使指针 p1
指向变量 i
。printf("%4d", *p1 + 20);
输出 i
的值(10)加 20,即 30,%4d
表示以至少 4 个字符的宽度输出整数,右对齐。for (p1 = a; p1 < a + 4; p1 += 2)
循环遍历数组 a
,每次增加 2 个元素。在循环中:printf("%4d", *p1);
输出当前指针 p1
所指向的数组元素的值,%4d
表示以至少 4 个字符的宽度输出整数,右对齐。printf("\n%c\t%s\n", *(b + 4), *p2);
输出字符串 b
中第 5 个字符(索引从 0 开始)和 p2
所指向的字符串(即 "Learning")。\t
表示一个制表符,用于输出对齐。
第一行输出 *p1 + 20
的结果,即 30
。第二行输出数组 a
中索引为偶数的元素,即 10
和 30
。第三行输出字符串 b
的第 5 个字符('n')和 p2
所指向的字符串("Learning")。注意,*(b + 4)
是获取字符串 b
中第 5 个字符,而 *p2
是获取 p2
所指向的字符串,即 b
所指向的字符串。所以输出结果为:
30
10 30
n Learning
3、编程题
3.1、 从键盘输入两个字符串a,b ,输出其由a与b字符串中字符从小到大的顺序排列的新的字符串。试编程
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{string a,b;//定义俩字符串cout << "please enter the first string : " ;cin >> a;//输入字符串acout << "please enter the second string : " ;cin >> b;//输入字符串bstring c =a+b;//将字符串a、b拼接到一起cout << "拼接后的字符串为:" << c << endl;sort(c.begin(),c.end());//排序cout << "排序后的字符串为:" << c;return 0;
}