高级语言程序设计C++复习题.docx
《高级语言程序设计C++复习题.docx》由会员分享,可在线阅读,更多相关《高级语言程序设计C++复习题.docx(29页珍藏版)》请在冰点文库上搜索。
高级语言程序设计C++复习题
高级语言程序设计(C++)
一、单项选择题
1、在一个C++程序中,main函数的位置( 3 )。
①必须在程序的开头 ②必须在程序的后面
③可以在程序的任何地方 ④必须在其它函数中间
2、C++程序基本单位是( 3 )。
①数据 ②字符 ③函数 ④语句
3、执行语句inti=10,*p=&i; 后,下面描述错误的是( 1 )。
①p的值为10 ②p指向整型变量i
③*p表示变量i的值 ④p的值是变量i的地址
4、执行语句inta=5,b=10,c;int*p1=&a,*p2=&b; 后,下面不正确的赋值语句是( 2 )。
①*p2=b;②p1=a;③p2=p1;④c=*p1×(*p2);
5、设i=1,j=2,则表达式i+++j的值为( 3 )。
①1②2③3④
6、设i=1,j=2,则表达式++i+j的值为(4 )。
7、执行下列语句后,x的值是( 4 ),y的值是(3 )。
intx,y;
x=y=1;++x||++y;
①不确定②0③1④2
8、已知x=5,则执行语句 x+=x-=x*x;后,x的值为( 3 )。
①25②40③-40④20
9、已知a=4,b=6,c=8,d=9,则”(a++,b>a++&&c>d)?
++d:
a
①9②6③8④0
10、有如下程序段:
inta=14,b=15,x;
charc=’A’;
x=(a&&b)&&(c<’B’);
执行该程序段后,x的值为(4 )。
①ture②false③0④1
11、下面程序的输出结果是(4 )。
#include
usingnamespacestd;
intmain()
{inta=6,b=6;
if(a>5)
a-=1;
b+=1;
else
a+=1;
b-=1;
cout<<“a=“<cout<<“b”<return0;}①57②a=5b=7③a=5b=6④编译时出错12、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta=6,b=6;if(a>5){a-=1;b+=1;}else{a+=1;b-=1;}cout<<“a=“<cout<<“b”<return0;}①57②a=5b=7③a=5b=6④a=6b=513、下面程序的输出结果是( 3 )#includeusingnamespacestd;intmain(){intx=6,y=8;if(x++<6)cout<<++y<if(x>6)cout<<--yelsecout<return0;}①8②7③9④编译时出错14、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){intx=6,y=8;if(++x<6)cout<<++y<elsecout<if(x>6)cout<<--y<return0;}①88②97③78④编译时出错15、下面程序的输出结果是( 1 )#includeusingnamespacestd;f(inta){intb=0;staticintc=3;b++;c++;return(a+b+c);}intmain(){inta=2,i;for(i=0;i<3;i++)cout<return0;}①789②777③71013④791116、下面程序的输出结果是( 3 )#includeusingnamespacestd;voidfun(intx,inty,intz){z=x*x+y*y;}intmain(){intz=68;fun(5,2,z);cout<return0;}①0②29③68④无定值17、下面程序的输出结果是( )#includeusingnamespacestd;intfun(inta,intb){return(++a*b++);}intmain(){intx=3,y=4,z=5,r;r=fun(fun(x,y),z);cout<}①8534②6034③12645④854518、下面的程序中,当输入4、2时,其输出结果是( )#includeusingnamespacestd;longfib(intn){if(n>2)return(fib(n-1)+fib(n-2));elsereturn(n);}intmain(){inti;cout<<“请输入一个整数:”;cin>>i;cout<cout<return0;}①51②42③52④6219、下面程序的输出结果为( )#includeusingnamespacestd;unsignedfunc(unsignednum){unsignedd=1,k;do{k=num%10;num/=10;}while(num);return(k);}intmain(){unsignedn=26;cout<return0;}①2②4③6④520、下面程序的输出结果为( )#includeusingnamespacestd;intfunc(inta,intb){intc;c=a*b;return(c);}intmain(){intx=6,y=7,z=8,r;r=func((x--,y,x*y),z--);cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
cout<<“b”<
return0;}
①57②a=5b=7③a=5b=6④编译时出错
12、下面程序的输出结果是( )
{a-=1;
b+=1;}
{a+=1;
b-=1;}
cout<<“a=“<cout<<“b”<return0;}①57②a=5b=7③a=5b=6④a=6b=513、下面程序的输出结果是( 3 )#includeusingnamespacestd;intmain(){intx=6,y=8;if(x++<6)cout<<++y<if(x>6)cout<<--yelsecout<return0;}①8②7③9④编译时出错14、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){intx=6,y=8;if(++x<6)cout<<++y<elsecout<if(x>6)cout<<--y<return0;}①88②97③78④编译时出错15、下面程序的输出结果是( 1 )#includeusingnamespacestd;f(inta){intb=0;staticintc=3;b++;c++;return(a+b+c);}intmain(){inta=2,i;for(i=0;i<3;i++)cout<return0;}①789②777③71013④791116、下面程序的输出结果是( 3 )#includeusingnamespacestd;voidfun(intx,inty,intz){z=x*x+y*y;}intmain(){intz=68;fun(5,2,z);cout<return0;}①0②29③68④无定值17、下面程序的输出结果是( )#includeusingnamespacestd;intfun(inta,intb){return(++a*b++);}intmain(){intx=3,y=4,z=5,r;r=fun(fun(x,y),z);cout<}①8534②6034③12645④854518、下面的程序中,当输入4、2时,其输出结果是( )#includeusingnamespacestd;longfib(intn){if(n>2)return(fib(n-1)+fib(n-2));elsereturn(n);}intmain(){inti;cout<<“请输入一个整数:”;cin>>i;cout<cout<return0;}①51②42③52④6219、下面程序的输出结果为( )#includeusingnamespacestd;unsignedfunc(unsignednum){unsignedd=1,k;do{k=num%10;num/=10;}while(num);return(k);}intmain(){unsignedn=26;cout<return0;}①2②4③6④520、下面程序的输出结果为( )#includeusingnamespacestd;intfunc(inta,intb){intc;c=a*b;return(c);}intmain(){intx=6,y=7,z=8,r;r=func((x--,y,x*y),z--);cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
①57②a=5b=7③a=5b=6④a=6b=5
13、下面程序的输出结果是( 3 )
{intx=6,y=8;
if(x++<6)
cout<<++y<if(x>6)cout<<--yelsecout<return0;}①8②7③9④编译时出错14、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){intx=6,y=8;if(++x<6)cout<<++y<elsecout<if(x>6)cout<<--y<return0;}①88②97③78④编译时出错15、下面程序的输出结果是( 1 )#includeusingnamespacestd;f(inta){intb=0;staticintc=3;b++;c++;return(a+b+c);}intmain(){inta=2,i;for(i=0;i<3;i++)cout<return0;}①789②777③71013④791116、下面程序的输出结果是( 3 )#includeusingnamespacestd;voidfun(intx,inty,intz){z=x*x+y*y;}intmain(){intz=68;fun(5,2,z);cout<return0;}①0②29③68④无定值17、下面程序的输出结果是( )#includeusingnamespacestd;intfun(inta,intb){return(++a*b++);}intmain(){intx=3,y=4,z=5,r;r=fun(fun(x,y),z);cout<}①8534②6034③12645④854518、下面的程序中,当输入4、2时,其输出结果是( )#includeusingnamespacestd;longfib(intn){if(n>2)return(fib(n-1)+fib(n-2));elsereturn(n);}intmain(){inti;cout<<“请输入一个整数:”;cin>>i;cout<cout<return0;}①51②42③52④6219、下面程序的输出结果为( )#includeusingnamespacestd;unsignedfunc(unsignednum){unsignedd=1,k;do{k=num%10;num/=10;}while(num);return(k);}intmain(){unsignedn=26;cout<return0;}①2②4③6④520、下面程序的输出结果为( )#includeusingnamespacestd;intfunc(inta,intb){intc;c=a*b;return(c);}intmain(){intx=6,y=7,z=8,r;r=func((x--,y,x*y),z--);cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
if(x>6)
cout<<--yelsecout<return0;}①8②7③9④编译时出错14、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){intx=6,y=8;if(++x<6)cout<<++y<elsecout<if(x>6)cout<<--y<return0;}①88②97③78④编译时出错15、下面程序的输出结果是( 1 )#includeusingnamespacestd;f(inta){intb=0;staticintc=3;b++;c++;return(a+b+c);}intmain(){inta=2,i;for(i=0;i<3;i++)cout<return0;}①789②777③71013④791116、下面程序的输出结果是( 3 )#includeusingnamespacestd;voidfun(intx,inty,intz){z=x*x+y*y;}intmain(){intz=68;fun(5,2,z);cout<return0;}①0②29③68④无定值17、下面程序的输出结果是( )#includeusingnamespacestd;intfun(inta,intb){return(++a*b++);}intmain(){intx=3,y=4,z=5,r;r=fun(fun(x,y),z);cout<}①8534②6034③12645④854518、下面的程序中,当输入4、2时,其输出结果是( )#includeusingnamespacestd;longfib(intn){if(n>2)return(fib(n-1)+fib(n-2));elsereturn(n);}intmain(){inti;cout<<“请输入一个整数:”;cin>>i;cout<cout<return0;}①51②42③52④6219、下面程序的输出结果为( )#includeusingnamespacestd;unsignedfunc(unsignednum){unsignedd=1,k;do{k=num%10;num/=10;}while(num);return(k);}intmain(){unsignedn=26;cout<return0;}①2②4③6④520、下面程序的输出结果为( )#includeusingnamespacestd;intfunc(inta,intb){intc;c=a*b;return(c);}intmain(){intx=6,y=7,z=8,r;r=func((x--,y,x*y),z--);cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
cout<return0;}①8②7③9④编译时出错14、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){intx=6,y=8;if(++x<6)cout<<++y<elsecout<if(x>6)cout<<--y<return0;}①88②97③78④编译时出错15、下面程序的输出结果是( 1 )#includeusingnamespacestd;f(inta){intb=0;staticintc=3;b++;c++;return(a+b+c);}intmain(){inta=2,i;for(i=0;i<3;i++)cout<return0;}①789②777③71013④791116、下面程序的输出结果是( 3 )#includeusingnamespacestd;voidfun(intx,inty,intz){z=x*x+y*y;}intmain(){intz=68;fun(5,2,z);cout<return0;}①0②29③68④无定值17、下面程序的输出结果是( )#includeusingnamespacestd;intfun(inta,intb){return(++a*b++);}intmain(){intx=3,y=4,z=5,r;r=fun(fun(x,y),z);cout<}①8534②6034③12645④854518、下面的程序中,当输入4、2时,其输出结果是( )#includeusingnamespacestd;longfib(intn){if(n>2)return(fib(n-1)+fib(n-2));elsereturn(n);}intmain(){inti;cout<<“请输入一个整数:”;cin>>i;cout<cout<return0;}①51②42③52④6219、下面程序的输出结果为( )#includeusingnamespacestd;unsignedfunc(unsignednum){unsignedd=1,k;do{k=num%10;num/=10;}while(num);return(k);}intmain(){unsignedn=26;cout<return0;}①2②4③6④520、下面程序的输出结果为( )#includeusingnamespacestd;intfunc(inta,intb){intc;c=a*b;return(c);}intmain(){intx=6,y=7,z=8,r;r=func((x--,y,x*y),z--);cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
①8②7③9④编译时出错
14、下面程序的输出结果是( )
if(++x<6)
cout<<++y<elsecout<if(x>6)cout<<--y<return0;}①88②97③78④编译时出错15、下面程序的输出结果是( 1 )#includeusingnamespacestd;f(inta){intb=0;staticintc=3;b++;c++;return(a+b+c);}intmain(){inta=2,i;for(i=0;i<3;i++)cout<return0;}①789②777③71013④791116、下面程序的输出结果是( 3 )#includeusingnamespacestd;voidfun(intx,inty,intz){z=x*x+y*y;}intmain(){intz=68;fun(5,2,z);cout<return0;}①0②29③68④无定值17、下面程序的输出结果是( )#includeusingnamespacestd;intfun(inta,intb){return(++a*b++);}intmain(){intx=3,y=4,z=5,r;r=fun(fun(x,y),z);cout<}①8534②6034③12645④854518、下面的程序中,当输入4、2时,其输出结果是( )#includeusingnamespacestd;longfib(intn){if(n>2)return(fib(n-1)+fib(n-2));elsereturn(n);}intmain(){inti;cout<<“请输入一个整数:”;cin>>i;cout<cout<return0;}①51②42③52④6219、下面程序的输出结果为( )#includeusingnamespacestd;unsignedfunc(unsignednum){unsignedd=1,k;do{k=num%10;num/=10;}while(num);return(k);}intmain(){unsignedn=26;cout<return0;}①2②4③6④520、下面程序的输出结果为( )#includeusingnamespacestd;intfunc(inta,intb){intc;c=a*b;return(c);}intmain(){intx=6,y=7,z=8,r;r=func((x--,y,x*y),z--);cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
cout<if(x>6)cout<<--y<return0;}①88②97③78④编译时出错15、下面程序的输出结果是( 1 )#includeusingnamespacestd;f(inta){intb=0;staticintc=3;b++;c++;return(a+b+c);}intmain(){inta=2,i;for(i=0;i<3;i++)cout<return0;}①789②777③71013④791116、下面程序的输出结果是( 3 )#includeusingnamespacestd;voidfun(intx,inty,intz){z=x*x+y*y;}intmain(){intz=68;fun(5,2,z);cout<return0;}①0②29③68④无定值17、下面程序的输出结果是( )#includeusingnamespacestd;intfun(inta,intb){return(++a*b++);}intmain(){intx=3,y=4,z=5,r;r=fun(fun(x,y),z);cout<}①8534②6034③12645④854518、下面的程序中,当输入4、2时,其输出结果是( )#includeusingnamespacestd;longfib(intn){if(n>2)return(fib(n-1)+fib(n-2));elsereturn(n);}intmain(){inti;cout<<“请输入一个整数:”;cin>>i;cout<cout<return0;}①51②42③52④6219、下面程序的输出结果为( )#includeusingnamespacestd;unsignedfunc(unsignednum){unsignedd=1,k;do{k=num%10;num/=10;}while(num);return(k);}intmain(){unsignedn=26;cout<return0;}①2②4③6④520、下面程序的输出结果为( )#includeusingnamespacestd;intfunc(inta,intb){intc;c=a*b;return(c);}intmain(){intx=6,y=7,z=8,r;r=func((x--,y,x*y),z--);cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
cout<<--y<return0;}①88②97③78④编译时出错15、下面程序的输出结果是( 1 )#includeusingnamespacestd;f(inta){intb=0;staticintc=3;b++;c++;return(a+b+c);}intmain(){inta=2,i;for(i=0;i<3;i++)cout<return0;}①789②777③71013④791116、下面程序的输出结果是( 3 )#includeusingnamespacestd;voidfun(intx,inty,intz){z=x*x+y*y;}intmain(){intz=68;fun(5,2,z);cout<return0;}①0②29③68④无定值17、下面程序的输出结果是( )#includeusingnamespacestd;intfun(inta,intb){return(++a*b++);}intmain(){intx=3,y=4,z=5,r;r=fun(fun(x,y),z);cout<}①8534②6034③12645④854518、下面的程序中,当输入4、2时,其输出结果是( )#includeusingnamespacestd;longfib(intn){if(n>2)return(fib(n-1)+fib(n-2));elsereturn(n);}intmain(){inti;cout<<“请输入一个整数:”;cin>>i;cout<cout<return0;}①51②42③52④6219、下面程序的输出结果为( )#includeusingnamespacestd;unsignedfunc(unsignednum){unsignedd=1,k;do{k=num%10;num/=10;}while(num);return(k);}intmain(){unsignedn=26;cout<return0;}①2②4③6④520、下面程序的输出结果为( )#includeusingnamespacestd;intfunc(inta,intb){intc;c=a*b;return(c);}intmain(){intx=6,y=7,z=8,r;r=func((x--,y,x*y),z--);cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
①88②97③78④编译时出错
15、下面程序的输出结果是( 1 )
f(inta)
{intb=0;
staticintc=3;
b++;c++;
return(a+b+c);
}
{inta=2,i;
for(i=0;i<3;i++)
cout<return0;}①789②777③71013④791116、下面程序的输出结果是( 3 )#includeusingnamespacestd;voidfun(intx,inty,intz){z=x*x+y*y;}intmain(){intz=68;fun(5,2,z);cout<return0;}①0②29③68④无定值17、下面程序的输出结果是( )#includeusingnamespacestd;intfun(inta,intb){return(++a*b++);}intmain(){intx=3,y=4,z=5,r;r=fun(fun(x,y),z);cout<}①8534②6034③12645④854518、下面的程序中,当输入4、2时,其输出结果是( )#includeusingnamespacestd;longfib(intn){if(n>2)return(fib(n-1)+fib(n-2));elsereturn(n);}intmain(){inti;cout<<“请输入一个整数:”;cin>>i;cout<cout<return0;}①51②42③52④6219、下面程序的输出结果为( )#includeusingnamespacestd;unsignedfunc(unsignednum){unsignedd=1,k;do{k=num%10;num/=10;}while(num);return(k);}intmain(){unsignedn=26;cout<return0;}①2②4③6④520、下面程序的输出结果为( )#includeusingnamespacestd;intfunc(inta,intb){intc;c=a*b;return(c);}intmain(){intx=6,y=7,z=8,r;r=func((x--,y,x*y),z--);cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
return0;
①789②777③71013④7911
16、下面程序的输出结果是( 3 )
voidfun(intx,inty,intz)
{z=x*x+y*y;}
{intz=68;
fun(5,2,z);
cout<return0;}①0②29③68④无定值17、下面程序的输出结果是( )#includeusingnamespacestd;intfun(inta,intb){return(++a*b++);}intmain(){intx=3,y=4,z=5,r;r=fun(fun(x,y),z);cout<}①8534②6034③12645④854518、下面的程序中,当输入4、2时,其输出结果是( )#includeusingnamespacestd;longfib(intn){if(n>2)return(fib(n-1)+fib(n-2));elsereturn(n);}intmain(){inti;cout<<“请输入一个整数:”;cin>>i;cout<cout<return0;}①51②42③52④6219、下面程序的输出结果为( )#includeusingnamespacestd;unsignedfunc(unsignednum){unsignedd=1,k;do{k=num%10;num/=10;}while(num);return(k);}intmain(){unsignedn=26;cout<return0;}①2②4③6④520、下面程序的输出结果为( )#includeusingnamespacestd;intfunc(inta,intb){intc;c=a*b;return(c);}intmain(){intx=6,y=7,z=8,r;r=func((x--,y,x*y),z--);cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
①0②29③68④无定值
17、下面程序的输出结果是( )
intfun(inta,intb)
{return(++a*b++);}
{intx=3,y=4,z=5,r;
r=fun(fun(x,y),z);
cout<}①8534②6034③12645④854518、下面的程序中,当输入4、2时,其输出结果是( )#includeusingnamespacestd;longfib(intn){if(n>2)return(fib(n-1)+fib(n-2));elsereturn(n);}intmain(){inti;cout<<“请输入一个整数:”;cin>>i;cout<cout<return0;}①51②42③52④6219、下面程序的输出结果为( )#includeusingnamespacestd;unsignedfunc(unsignednum){unsignedd=1,k;do{k=num%10;num/=10;}while(num);return(k);}intmain(){unsignedn=26;cout<return0;}①2②4③6④520、下面程序的输出结果为( )#includeusingnamespacestd;intfunc(inta,intb){intc;c=a*b;return(c);}intmain(){intx=6,y=7,z=8,r;r=func((x--,y,x*y),z--);cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
①8534②6034③12645④8545
18、下面的程序中,当输入4、2时,其输出结果是( )
longfib(intn)
{if(n>2)return(fib(n-1)+fib(n-2));
elsereturn(n);}
{inti;
cout<<“请输入一个整数:
”;
cin>>i;cout<cout<return0;}①51②42③52④6219、下面程序的输出结果为( )#includeusingnamespacestd;unsignedfunc(unsignednum){unsignedd=1,k;do{k=num%10;num/=10;}while(num);return(k);}intmain(){unsignedn=26;cout<return0;}①2②4③6④520、下面程序的输出结果为( )#includeusingnamespacestd;intfunc(inta,intb){intc;c=a*b;return(c);}intmain(){intx=6,y=7,z=8,r;r=func((x--,y,x*y),z--);cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
cout<return0;}①51②42③52④6219、下面程序的输出结果为( )#includeusingnamespacestd;unsignedfunc(unsignednum){unsignedd=1,k;do{k=num%10;num/=10;}while(num);return(k);}intmain(){unsignedn=26;cout<return0;}①2②4③6④520、下面程序的输出结果为( )#includeusingnamespacestd;intfunc(inta,intb){intc;c=a*b;return(c);}intmain(){intx=6,y=7,z=8,r;r=func((x--,y,x*y),z--);cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
①51②42③52④62
19、下面程序的输出结果为( )
unsignedfunc(unsignednum)
{unsignedd=1,k;
do{
k=num%10;
num/=10;
}while(num);
return(k);}
{unsignedn=26;
cout<return0;}①2②4③6④520、下面程序的输出结果为( )#includeusingnamespacestd;intfunc(inta,intb){intc;c=a*b;return(c);}intmain(){intx=6,y=7,z=8,r;r=func((x--,y,x*y),z--);cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
①2②4③6④5
20、下面程序的输出结果为( )
intfunc(inta,intb)
{intc;
c=a*b;
return(c);
{intx=6,y=7,z=8,r;
r=func((x--,y,x*y),z--);
cout<return0;}①294②245③280④41621、下面程序的输出结果为( 1 )#includeusingnamespacestd;intmain(){inta[3][3]={{1,2},{3,4},{5}};ints=0;for(inti=1;i<3;i++)for(intj=0;j<=i;j++)s+=a[i][j];cout<return0;}①12②14③15④1322、下面程序的输出结果是( )#includeusingnamespacestd;voidfun(int*x,int*y){cout<<*x<<““<<*y<<““;x=3;y=4;}intmain(){intx=1,y=2;fun(&y,&x);cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
①294②245③280④416
21、下面程序的输出结果为( 1 )
{inta[3][3]={{1,2},{3,4},{5}};ints=0;
for(inti=1;i<3;i++)
for(intj=0;j<=i;j++)
s+=a[i][j];
cout<
①12②14③15④13
22、下面程序的输出结果是( )
voidfun(int*x,int*y)
{
cout<<*x<<““<<*y<<““;
x=3;y=4;}
{intx=1,y=2;
fun(&y,&x);
cout<return0;}①2143②1212③2112④123423、下面程序的输出结果是( )#includeusingnamespacestd;intmain(){inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;cout<<*--p;return0;}① 编译出错 ② a[4]的地址 ③5④324、关于类和对象不正确的说法是( 3 )1类是一种类型,它封装了数据和操作 ②对象是类的实例③一个类的对象只有一个 ④一个对象必属于某个类26、作用域运算符的功能是(4)。①标识作用域的级别的②指出作用域的范围的③给定作用域的大小的④标识某个成员是属于哪个类的27、关于成员函数特征的下述描述中,(1)是错误的。①成员函数一定是内联函数②成员函数可以重载2成员函数可以设置参数的默认值④成员函数可以是静态的34、下列对重载函数的描述中,(1)是错的。①重载函数中不允许使用缺省参数②重载函数中编译系统根据参数表进行选择③不要使用重载函数来描述毫无相干的函数④构造函数重载将给初始化带来多种方式35、已知一个类A,()是指向类A成员函数的指针。假设类A有3个公有成员:Voidf1(int),voidf2(int)和inta。1A*p;②intA::*pc=&A::a;③voidA::*pa();④A*pp;36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是正确的1p=f1;②p=A::f1;③p=A::f1();④p=f1();37、已知:p是一个指向类A数据成员m的指针,a1是类A的一个对象。如果要给m赋值为5,()是正确的。1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;38、已知类A中一个成员函数说明如下:voidSet(A &a)其中,A &a的含意是(3)。1指向类A的指针为a②将A的地址值赋给变量Set③a是类A的对象的引用,用来作函数Set()的形参④变量A与a按位相与作为函数Set()的参数40、下面程序的输出结果是( )#includeusingnamespacestd;classpoint{public:voidpoi(intpx=10,intpy=10){x=px;y=py;}intgetpx(){returnx;}intgetpy(){returny;}private:intx,y;};intmain(){pointp,q;p.poi();q.poi(15,15);cout<<“p点的坐标是:”<cout<cout<<“q点的坐标是:”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
①2143②1212③2112④1234
23、下面程序的输出结果是( )
{inta[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5;
cout<<*--p;
① 编译出错 ② a[4]的地址 ③5④3
24、关于类和对象不正确的说法是( 3 )
1类是一种类型,它封装了数据和操作 ②对象是类的实例
③一个类的对象只有一个 ④一个对象必属于某个类
26、作用域运算符的功能是(4)。
①标识作用域的级别的②指出作用域的范围的
③给定作用域的大小的④标识某个成员是属于哪个类的
27、关于成员函数特征的下述描述中,
(1)是错误的。
①成员函数一定是内联函数②成员函数可以重载
2成员函数可以设置参数的默认值④成员函数可以是静态的
34、下列对重载函数的描述中,
(1)是错的。
①重载函数中不允许使用缺省参数
②重载函数中编译系统根据参数表进行选择
③不要使用重载函数来描述毫无相干的函数
④构造函数重载将给初始化带来多种方式
35、已知一个类A,()是指向类A成员函数的指针。
假设类A有3个公有成员:
Voidf1(int),voidf2(int)和inta。
1A*p;②intA:
:
*pc=&A:
a;③voidA:
*pa();④A*pp;
36、已知f1(int)是类A的公有成员函数,p是指向成员函数f1()的指针,采用()是
正确的
1p=f1;②p=A:
f1;③p=A:
f1();④p=f1();
37、已知:
p是一个指向类A数据成员m的指针,a1是类A的一个对象。
如果要给m赋值
为5,()是正确的。
1a1.p=5;②a1->p=5;③a1.*p=5;④*a1.p=5;
38、已知类A中一个成员函数说明如下:
voidSet(A &a)
其中,A &a的含意是(3)。
1指向类A的指针为a
②将A的地址值赋给变量Set
③a是类A的对象的引用,用来作函数Set()的形参
④变量A与a按位相与作为函数Set()的参数
40、下面程序的输出结果是( )
classpoint
public:
voidpoi(intpx=10,intpy=10)
{x=px;y=py;}
intgetpx()
{returnx;}
intgetpy()
{returny;}
private:
};
pointp,q;
p.poi();
q.poi(15,15);
cout<<“p点的坐标是:
”<
cout<<“q点的坐标是:
”<cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
cout<return0;}①p点的坐标是:10,10②p点的坐标是:0,0q点的坐标是:15,15q点的坐标是:15,15×√③p点的坐标是:0,0④p点的坐标是:10,10q点的坐标是:0,0q点的坐标是:10,10二、判断题1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。( × 1 )2、在命名标识符中,大小写字母是不加区分的。( √23、引用是某个变量的别名。对引用的操作,实质上就是对被引用的变量的操作。( 2 )4、typedef类型定义是原来定义一些C++中所没有的新类型。15、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。( 2 )7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。( 2 )8、条件编译命令只在编译时才有用。(2 )9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。( 1 )10、switch语句中必须有break语句,否则无法退出switch语句。( 1 )11、while循环语句的循环体最少执行一次。( 1 )12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。( 1 )13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。(1 )14、在多重循环中,内重循环的循环变量引用的次数比外重的多。(2 )15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。(2 )16、如果一个函数没有返回值,定义时需用void说明。( 2 )17、使用内置函数是以增大空间开销为代价的。( 2 )18、返回值类型、参数个数和类型都相同的函数也可以重载。( 1 )19、在设置了参数默认值后,调用函数的对应实参就必须省略。( 1 )20、函数形参的作用域是该函数的函数体。( 2 )21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。( 2 )22、内部静态类变量与自动类变量作用域相同,但是生存期不同。( 2 )23、静态类标识符在它的作用域之外是不存在的。( 1 )24、使用关键字class定义的类中默认的访问权限是私有的(private)。(2)25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。(2)三、填空题1、下面程序是计算1~10之间偶数之和,请填空:#includeusingnamespacestd;intmain(){inta,b,i;a=0;b=0;for(i=0;①;i++){a+=i;②;③;cout<<“偶数之和为:”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
①p点的坐标是:
10,10②p点的坐标是:
0,0
q点的坐标是:
15,15q点的坐标是:
15,15×√
③p点的坐标是:
0,0④p点的坐标是:
10,10
0,0q点的坐标是:
二、判断题
1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。
( × 1 )
2、在命名标识符中,大小写字母是不加区分的。
( √2
3、引用是某个变量的别名。
对引用的操作,实质上就是对被引用的变量的操作。
( 2 )
4、typedef类型定义是原来定义一些C++中所没有的新类型。
1
5、枚举变量的取值收到该枚举变量所对应的枚举表中枚举常量的局限。
7、预处理命令是在进行编译时首先执行的,然后再进行正常编译。
8、条件编译命令只在编译时才有用。
(2 )
9、switch语句不可以嵌套,在开关语句的语句序列中不能再有开关语句。
( 1 )
10、switch语句中必须有break语句,否则无法退出switch语句。
11、while循环语句的循环体最少执行一次。
12、只有for循环的循环体可以是空语句,其它种类循环的循环体不能用空语句。
13、当循环体为空语句时,说明该循环体不做任何工作,只起延时作用。
(1 )
14、在多重循环中,内重循环的循环变量引用的次数比外重的多。
15、在C++中,说明函数时要用函数原型,即定义函数时的函数头部分。
16、如果一个函数没有返回值,定义时需用void说明。
17、使用内置函数是以增大空间开销为代价的。
18、返回值类型、参数个数和类型都相同的函数也可以重载。
19、在设置了参数默认值后,调用函数的对应实参就必须省略。
20、函数形参的作用域是该函数的函数体。
21、定义外部变量时,不用存储类说明符extern,而声明外部变量时用它。
22、内部静态类变量与自动类变量作用域相同,但是生存期不同。
23、静态类标识符在它的作用域之外是不存在的。
24、使用关键字class定义的类中默认的访问权限是私有的(private)。
(2)
25、指向对象的指针和指向类的成员的指针在表达形式上是不相同的。
三、填空题
1、下面程序是计算1~10之间偶数之和,请填空:
{inta,b,i;
a=0;b=0;
for(i=0;①;i++)
{a+=i;
②;
③;
cout<<“偶数之和为:
”<return0;}2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:#includeusingnamespacestd;intmain(){inti,j;for(i=0;①;i++){j=i*10+6;if(②)continue;③;cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
2、下面程序是输出100内能被3整除且个位数是6的所有整数,请填空:
{inti,j;
{j=i*10+6;
if(②)
continue;
cout<④;return0;}3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。4、常量与变量的区别是:常量在程序运行中值 ,因此它的值在编译时便进行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。若 不同,则按一般规则转换,若 不同,则 。6、函数的递归分为 , ,递归由 、 两部分组成。一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。7、下面程序的功能是:求a的b次方,并输出,请填空。#includeusingnamespacestd;doublefun(doublea,intb){inti;doublez;for(i=1,z=1;i<=b;i++)①;②;}intmain(){doublea;intb;cout<<“请输入a的值:”;③;cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
④;
3、结构体类型与数组不同,数组中的数据的类型是 的,结构体的成员的数据类型
是 ,共用体类似于结构体,但是共用体的部分成员是 ,枚举类型是 的集合。
4、常量与变量的区别是:
常量在程序运行中值 ,因此它的值在编译时便进
行;而变量的值是可以 , 类型的变量存储的是变量的地址,不是变量的 。
5、函数的形参在未被调用前 分配空间,函数的形参的 要和实参相同。
若 不同,则按一般规则转换,若 不同,则 。
6、函数的递归分为 , ,递归由 、 两部分
组成。
一般说,一个问题的解决要依靠另一问题的解决,而另一个问题的解决方法与上一问题的解决方法相同,则可用 处理。
7、下面程序的功能是:
求a的b次方,并输出,请填空。
doublefun(doublea,intb)
doublez;
for(i=1,z=1;i<=b;i++)
①;
{doublea;intb;
cout<<“请输入a的值:
”;
cout<cout<<“请输入b的值:”;④;cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
cout<<“请输入b的值:
cout<cout<<⑤;cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
cout<<⑤;
cout<return0;}8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。#includeusingnamespacestd;①;fun(charch){inti;if((ch>=’a’)&&(ch<=’z’)i=1;else{if(②)i=2;elsei=3;}③;intmain(){inti;cout<<“请输入一个字符:”;cin>>ch;i=fun(ch);if(i==1)cout<<“是小写字母:”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
8、下面函数是检验输入的字符是大写还是小写或者不是26个字母,请填空。
fun(charch)
if((ch>=’a’)&&(ch<=’z’)
i=1;
else{if(②)
i=2;
elsei=3;}
cout<<“请输入一个字符:
cin>>ch;
i=fun(ch);
if(i==1)
cout<<“是小写字母:
”<elseif(④)cout<<“是大写字母:”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
elseif(④)
cout<<“是大写字母:
”<elsecout<<“是其它字符:”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
elsecout<<“是其它字符:
”<return0;}9、下面是字符串拷贝程序,请填空。voidccopy(){charch1[]=“goodmorning!”,ch2[20];inti=0,j=0;while(①){ch2[j]=②;③;}④;}10、下面函数是寻找二维数组中每一行的最大值,请填空。#defineN5#defineM5voidmax(inta[N][M]){inti,j,p;for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
9、下面是字符串拷贝程序,请填空。
voidccopy()
{charch1[]=“goodmorning!
”,ch2[20];
inti=0,j=0;
while(①)
{ch2[j]=②;
10、下面函数是寻找二维数组中每一行的最大值,请填空。
#defineN5
#defineM5
voidmax(inta[N][M])
{inti,j,p;
for(i=0;i{①;for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
{①;
for(j=1;jif(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
if(a[i][p]②;cout<”<}}11、下面程序是将字符逆序化,请填空。#includeusingnamespacestd;①;intmain(){charch[]=“hello,boy!”;charc;inti=0,j=strlen(ch);for(;②;i++,j--){c=ch[i];③;ch[j-1]=c;}cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
11、下面程序是将字符逆序化,请填空。
{charch[]=“hello,boy!
charc;
inti=0,j=strlen(ch);
for(;②;i++,j--)
{c=ch[i];
ch[j-1]=c;
cout<return0;} 12、下面程序的功能是将矩阵转置,请填空。#includeusingnamespacestd;#defineI3#defineJ4voidinvert(inta[I][J]){inti,j;intb[J][I];cout<<“arraya:”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
12、下面程序的功能是将矩阵转置,请填空。
#defineI3
#defineJ4
voidinvert(inta[I][J])
intb[J][I];
cout<<“arraya:
”<for(i=0;i{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
for(i=0;i
{for(j=0;j{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
{cout<①;}cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
cout<}cout<<“arrayb:”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
cout<<“arrayb:
”<for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
for(i=0;i{for(j=0;jcout<cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
{for(j=0;j
cout<}}intmain(){inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};②;return0;}四、程序分析题1、下面程序的输出结果是( )#includeusingnamespacestd;intfunc(inta,intb){staticintm=0;inti=2;i+=m+1;m=i+a+b;return(m);}intmain(){intk=4,m=1,p;p=func(k,m);cout<p=func(k,m);cout<return0;}2、下面程序的输出结果是( )#includeusingnamespacestd;intd=1;intfun(intp){staticintd=5;d+=p;cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
{inta[I][J]={{1,2,3,4},{5,6,7,8},{1,3,5,7}};
四、程序分析题
1、下面程序的输出结果是( )
{staticintm=0;inti=2;
i+=m+1;
m=i+a+b;
return(m);
{intk=4,m=1,p;
p=func(k,m);
2、下面程序的输出结果是( )
intd=1;
intfun(intp)
{staticintd=5;
d+=p;
cout<return(d);}intmain(){inta=3;cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
return(d);
{inta=3;
cout<return0;}3、下面程序的执行结果是( )#includeusingnamespacestd;charch[]=“hello,boy!”;voidfun2(inti);voidfun1(inti){cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
3、下面程序的执行结果是( )
charch[]=“hello,boy!
voidfun2(inti);
voidfun1(inti)
{cout<if(i<3){i+=2;fun2(i);}}voidfun2(inti){cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
if(i<3)
{i+=2;
fun2(i);}
voidfun2(inti)
{cout<if(i<3){i+=2;fun1(i);}}intmain(){inti=0;fun1(i);cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
fun1(i);}
{inti=0;
fun1(i);
cout<return0;}4、下面程序的执行结果是( )#includeusingnamespacestd;intmain(){inta[10]={0,1,2};intj;for(j=2;j<6;j++)a[j+1]=a[j]+2*a[j-1]*a[j-2];for(j=0;j<6;j++)cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
4、下面程序的执行结果是( )
{inta[10]={0,1,2};
intj;
for(j=2;j<6;j++)
a[j+1]=a[j]+2*a[j-1]*a[j-2];
for(j=0;j<6;j++)
cout<<“a[“<return0;}5、当输入123时,下列程序的输出结果是( )#includeusingnamespacestd;intmain(){intstr[3],i,*p=str;for(i=0;i<3;i++){cin>>*p++;cout<<*(p-1);}return0;}6、下面程序的输出结果是( )#include
5、当输入123时,下列程序的输出结果是( )
{intstr[3],i,*p=str;
{cin>>*p++;
cout<<*(p-1);}
6、下面程序的输出结果是( )
copyright@ 2008-2023 冰点文库 网站版权所有
经营许可证编号:鄂ICP备19020893号-2