moocC++程序设计_9章节答案(mooc完整答案)
14 min readmoocC++程序设计_9章节答案(mooc完整答案)
第1讲 了解计算机的序设基本工作原理
1、以下都可用作计算机输入设备的计章节答是：
A、键盘，案m案鼠标，整答扫描仪，序设打印机
B、计章节答键盘，案m案数码相机，整答鼠标，序设绘图仪
C、计章节答键盘，案m案数码相机，整答扫描仪，序设绘图仪
D、计章节答键盘，案m案鼠标，扫描仪，数码相机
2、CPU中包含控制器和：
A、运算器
B、存储器
C、输入设备
D、输出设备
3、下列语言不属于高级语言中的是：
A、C语言
B、机器语言
C、FORTRAN语言
D、C++语言
4、正确的C++语言标识符是：
A、3d_max
B、if
C、A&B
D、sum_2
5、对C++语言和C语言的兼容性，描述正确的是:
A、C++兼容C
B、C++部分兼容C
C、C++不兼容C
D、C兼容C++
第2讲 信息的表示与存储
第2讲 了解各种进位计数制及常用数据在计算机中的存储
1、下列数中最大的数为：
A、(101001)B
B、(52)O
C、(43)D
D、(2C)H
2、如果X为负数，由[X]补求[-X]补是将:
A、[X]补各值保持不变
B、[X]补符号位变反，其它各位不变
C、[X]补除符号位外，各位变反，未位加1
D、[X]补连同符号位一起各位变反，未位加1
3、以下叙述错误的是:
A、浮点数中，阶码反映了小数点的位置
B、浮点数中，阶码的位数越长，能表示的精度越高
C、计算机中，整数一般用定点数表示
D、浮点数和整数的最高位都是符号位
4、二进制数101101.101转换为十进制数、八进制数和十六进制数的结果分别是：
A、45.525、55.5、2D.A
B、45.625、55.5、2D.B
C、45.625、55.5、2D.A
D、45.625、55.6、2D.A
5、字符型数据'A'存放在计算机中：
A、存放的就是字母'A'
B、存放的是'A'的ASCII码值的补码
C、实际存放的是'A'的ASCII码值97
D、实际存放的是'A'的ASCII码值65
第3讲 程序中数据的表示
第3讲 掌握常量、变量的表示及基本数据类型
1、类型修饰符unsigned不能修饰
A、char
B、int
C、long int
D、float
2、在C++语言的数据类型中，int，short等类型的长度是
A、固定的
B、任意的
C、用户自定义的
D、与机器字长有关的
3、下列选项中，均是合法的整型常量的是：
A、60 -0xffff 0011
B、–0xcdf 01a 0xe
C、–01 986,012 0668
D、–0x48a 2e5 0x
4、下列选项中，均是合法的实型常量的是：
A、+1e+1 5e-9.4 03e2
B、-0.10 12e-4 -8e5
C、123e 1.2e-.4 +2e-1
D、–e3 .8e-4 5.e-0
5、下列字符串常量表示中，哪个是错误的？
A、"\"yes"or\"No\""
B、"\'OK!\'"
C、"abcd\n"
D、"ABC\0"
6、字符串”\t\v\\\0which\n”的长度是：
A、4
B、3
C、9
D、字符串有非法字符，输出值不确定
7、以下不是C++语言支持的存储类别的是：
A、auto
B、static
C、dynamic
D、register
8、下列不是C++语言的合法用户标识符的是：
A、a#b
B、_int
C、a_10
D、Pad
9、下列字符列中，可作为C++语言程序自定义标识符是:
A、switch
B、file
C、break
D、do
10、下列属于逻辑运算的一组算式是：
A、1/1=1
B、1-1=0
C、1+1=10
D、1+1=1
第4讲 运算符与表达式
第4讲 掌握各种表达式的表示
1、命题“10<m<15或m>20”的C++语言表达式是
A、((m>10)&&(m<15)||(m>20))
B、((m>20)&&(m<15)||(m>10))
C、(m>10)||((m<15)&&(m>20))
D、((m>10)||(m<15)||(m>20))
2、设int a=3,b=4,c=5;表达式(a+b)>c&&b==c的值是：
A、2
B、-1
C、0
D、1
3、若x是一个bool型变量，y是一个值为100的int型变量，则表达式 !x && y>0 的值为：
A、为true
B、为false
C、与x的值相同
D、与x的值相反
4、设变量m，n，a，b，c，d均为0，执行(m = a==b)&&(n=c==d)后，m，n的值是：
A、0,0
B、0,1
C、1,0
D、1,1
5、设a和b均为double型变量，且a=5.5，b=2.5，则表达式（int）a+b/b的值是：
A、6.500000
B、6
C、5.500000
D、6.000000
6、以下非法的赋值表达式是：
A、n=(i=2,i++)
B、j++
C、++(i+1)
D、x=j>0
7、设int x=2，y=4，z=7；则执行x=y--＜=x| | x+y!=z后x，y的值分别为：
A、0,3
B、1,3
C、2,3
D、2,4
8、表达式!x等效于：
A、x==1
B、x==0
C、x!=1
D、x!=0
9、设以下变量均为int类型，则值不等于7的表达式是：
A、(x=y=6,x+y,x+1)
B、(x=y=6,x+y,y+1)
C、(x=6,x+1,y=6,x+y)
D、(y=6,y+1,x=y,x+1)
10、在下列成对的表达式中，运算符“+”的意义不相同的一对是：
A、5.0+2.0和5.0+2
B、5.0+2.0和5+2.0
C、5.0+2.0和5+2
D、5+2.0和5.0+2
第5讲 顺序结构的程序设计
第5讲 掌握C++输入输出的格式控制
1、输入输出格式控制是在哪个头文件中定义的？
A、iostream.h
B、iomanip.h
C、istream.h
D、ostream.h
2、对于语句cout<<endl<<x;中的各个组成部分，下列叙述中错误的是：
A、”cout”是一个输出流对象
B、”endl”的作用是输出回车换行
C、”x”是一个变量
D、”<<”称作提取运算符
3、在ios中提供控制格式的标志位中，哪个是转换为十六进制形式的标志位？
A、hex
B、oct
C、dec
D、left
4、定义变量：char one_char;则语句cout<<one_char;显示结果相当于C语言中的：
A、printf(one_char);
B、printf(“%c”,one_char);
C、scanf(one_char);
D、scanf(“%c”,&one_char);
5、若有定义“int x=17;”，则语句“cout<<oct<<x;”的输出结果是：
A、11
B、0x11
C、21
D、021
6、与C语言printf("Hello,World＼n")；语句功能相同的C++语句是：
A、cout>>"Hello,World＼n";
B、cout<<"Hello,World＼n";
C、cin>>"Hello,World＼n";
D、cin<<"Hello,World＼n";
7、与语句cout<<endl；不等价的是：
A、cout<<’ \n’;
B、cout<<'\12';
C、cout<<’ \xA’;
D、D）cout<<’ \0’;
8、下列程序的运行结果是: #include <iostream> using namespace std; int main() { int a=2; int b=a+1; cout<<a/b<<endl; return 0; }
A、0.66667
B、0
C、0.7
D、0.6666666...
9、执行下列代码，程序的输出结果是（用下划线表示空格）： int a=29，b=100； cout <<setw (3) << a << b << endl；
A、29_100
B、_29_100
C、29100
D、_29100
10、执行下列代码，程序的输出结果是： cout <<″Hex：″<< hex << 255；
A、ff
B、hex:ff
C、Hex:ff
D、f
第6讲 选择结构的程序设计
第6讲 掌握选择结构的程序设计
1、流程控制语句的基本控制结构有三种，不属于这一种结构的是：
A、顺序结构
B、选择结构
C、循环结构
D、计算结构
2、在设计程序时，应采纳的原则之一是：
A、不限制goto语句的使用
B、减少或取消注解行
C、程序越短越好
D、程序结构应有助于读者理解
3、if语句的语法格式可描述为： 格式1：if(<条件>)<语句>或if(<条件>)<语句1>else <语句2> 关于上面的语法格式，下列表述中错误的是：
A、<条件>部分可以是一个if语句，例如if(if(a==0)……)……
B、<语句>部分可以是一个if语句，例如if(……)if（……）……
C、如果在<条件>前加上逻辑非运算符！并交换<语句1>和<语句2>的位置，语句功 能不变
D、<语句>部分可以是一个循环语句，例如if(……) while（……）……
4、在if语句中的表达式是：
A、只能是表达式
B、只能是关系表达式和逻辑表达式
C、只能是逻辑表达式
D、可以是任意表达式
5、执行如下语句序列，不可能出现的情况是： int x; cin>>x; if(x>250) cout<<'A'; if(x<250) cout<<'B'; else cout<<'A';
A、显示：A
B、显示：B
C、显示：AB
D、显示：AA
6、阅读下面的程序，如果两次执行上述程序，且键盘输入分别是4和6，则输出结果是： #include <iostream> using namespace std; int main(){ int x; cin>>x; if (x++>5) cout <<x<<endl; else cout<<x--<<endl; return 0; }
A、4,6
B、3,6
C、4,7
D、5,7
7、下列描述正确的是：
A、表示m>n为false或m<n为true的表达式为（m>n&&m<n）
B、switch语句结构中必须有default语句
C、if语句结构中必须有default语句
D、如果至少有一个操作数为true，则包含||运算符的表达式为true
8、执行如下语句序列，不可能出现的情况是： int n; cin>>n; switch(n){ case 1: case 2: cout<<'A'; case 3: case 4: cout<<'B'; break; default:cout<<'C'; }
A、显示：A
B、显示：B
C、显示：C
D、显示：AB
9、关于switch语句的说明中，错误的是：
A、default语句是可缺省的
B、各个分支中的break语句起着退出switch语句的作用
C、switch结构不可以嵌套
D、每个case语句中不必用｛｝，而整体的switch结构一定要写一对花括号｛｝
10、将以下程序写成三目运算表达式语句是： if (a>b) max=a;else max=b;
A、max=(a>b)?;
B、(max=a>b)?a:b;
C、c=(a>b)?a:b;
D、max=(a>b)?a:b;
第7讲 循环结构的程序设计
第7讲 掌握循环结构的程序设计
1、while(!x)中的(!x)与下面哪个条件等价？
A、x==1
B、x!=1
C、x!=0
D、x==0
2、已知：int i=5,下列do-while循环语句的循环次数为： do{ cout<<i--<<endl; i--;}while(i!=0);
A、0
B、1
C、5
D、无限
3、下面程序段： x=3; do{ y=x--; if(!y) { cout<<”x”; continue; } cout<<”#”; }while(x>=1 && x<=2);
A、将输出##
B、是死循环
C、将输出###
D、含有不合法的控制表达式
4、for(int x=0,y=0;!x&&y<=5;y++)语句执行循环的次数是：
A、0
B、5
C、6
D、无限
5、以下程序的输出结果是： #include <iostream> using namespace std; int main(){ char s[]="abcdefbcde",*p=s; int v1=0,v2=0,v3=0,v4=0; for (p;*p;p++) switch(*p){ case 'a':v1++;break; case 'b':v3++;break; case 'e':v2++;break; default: v4++; } cout<<v1<<","<<v2<<","<<v3<<","<<v4<<endl; return 0; }
A、1,2,2,5
B、4,7,5,8
C、1,5,3,10
D、8,8,8,8
6、下面有关for循环的正确描述是:
A、for循环只能用于循环次数已经确定的情况
B、for循环是先执行循环体语句，后判断表达式
C、在for循环中，不能用break语句跳出循环体
D、for循环的循环体语句中，可以包含多条语句，但必须用大括号括起来
7、C++语言的跳转语句中，对于break和continue说法正确的是:
A、break语句只应用与循环体中
B、continue语句只应用与循环体中
C、break是无条件跳转语句，continue不是
D、break和continue的跳转范围不够明确，容易产生问题
8、下列循环语句的循环次数是： while（int i=0） i--;
A、0
B、1
C、2
D、3
9、下面程序的输出结果是： #include<iostream> using namespace std; int main(){ for(int i=-1;i<4;i++) cout<<(i?'0':'*'); return 0; }
A、0*0
B、0000
C、0*00
D、0*000
10、下面程序的输出结果是： #include "iostream" using namespace std; int main() { int i=17; while(i>=10) if(--i%4==3) continue; else cout<<"i="<<i--<<endl; return 0; }
A、i=16 i=15 i=14 i=13
B、i=16 i=14 i=12
C、i=16 i=14 i=12 i=10
D、i=17 i=15 i=13 i=11
第8讲 循环结构的设计
第8讲 掌握循环结构的程序设计
1、程序填空完成功能：求出1000以内的全部素数。 #include<iostream> using namespace std; int main(){ const int m=1000; int i,j,isprime; for (i=2;i<1000;i++){ isprime=1; for (j=i-1;j>1;j--) if (i%j==0) 【 】; if (isprime) cout<<i<<','; } return 0; }
2、程序填空完成功能：求分数序列2/1,3/2,5/3,8/5,13/8 ……的前20项之和。 #include <iostream> using namespace std; int main() { double i,n=1,m=1,t,s=0 ; for (i=1;i<=20;i++) { t = n ; n = m ; 【 】; s = s + m/n ; } cout<<s<<endl; return 0; }
3、程序填空完成功能：有一堆机器零件（零件个数小于100），3个为一组则剩下2个，5个为一组则剩下1个，7个为一组则剩下6个，求这堆零件一共有多少个？ #include <iostream> using namespace std; int main() { int i; for (i=1;i<100;i++) { if(【 】) cout<<i<<endl; } return 0; }
第9讲 函数的定义和使用
第9讲 掌握函数的定义和函数的调用方式
1、下列特性中，C与C++共有的是：
A、继承
B、封装
C、多态性
D、函数定义不能嵌套
2、必须用一对大括号括起来的程序段是：
A、switch语句中的case标号语句
B、if语句的分支
C、循环语句的循环体
D、函数的函数体
3、关于C++主函数特性，下列叙述正确的是：
A、主函数在同一个C++文件中可以有两个
B、主函数类型必须是void类型
C、主函数一定有返回值
D、每个C++程序都必须有一个main()函数
4、在C++语言中，main函数默认返回一个（ ）类型的值
A、int
B、float
C、char
D、void
5、C++语言中规定函数的返回值的类型是由：
A、return语句中的表达式类型所决定
B、调用该函数时的主调用函数类型所决定
C、调用该函数时系统临时决定
D、在定义该函数时多指定的数据类型所决定
6、若调用一个函数，且此函数中没有return语句，则正确的说法是该函数：
A、没有返回值
B、返回若干个系统默认值
C、有返回值，但返回一个不确定的值
D、回一个用户所希望的函数值
7、下列叙述中错误的是：
A、一个函数中可以有多条return语句
B、调用函数必须在一条独立的语句中完成
C、函数中通过return语句传递函数值
D、主函数名main也可以带有形参
8、在C++中把不返回任何类型的函数应该说明为：
A、int
B、float
C、char
D、void
9、在函数的定义格式中，下面各组成部分中，（ ）是可以省略的。
A、函数名
B、函数数据类型说明
C、函数体
D、函数参数
10、函数调用func((exp1,exp2),(exp3,exp4,exp5))中所含实参的个数为：
A、1
B、2
C、3
D、4
第10讲 函数的设计
第10讲 灵活运用函数重载、默认参数和函数模板
1、指出下列对定义重载函数的要求中，（ ）是错误的。
A、要求参数的个数相同
B、要求参数的类型相同时，参数个数不同
C、函数的返回值可以不同
D、要求参数的个数相同时，参数类型不同
2、一个函数为void x（int,char ch=’a’），另一个函数为void x(int)，则它们：
A、不能在同一程序中定义
B、可以在同一程序中定义并可重载
C、可以在同一程序中定义，但不可以重载
D、以上说法均不正确
3、重载函数在调用时选择的依据中，错误的是：
A、函数的参数
B、参数的类型
C、函数的名字
D、函数返回值类型
4、下列函数原型声明中错误的是：
A、void fun（int x=0,int y=0）;
B、void fun(int x,int y);
C、void fun(int x,int y=0);
D、void fun(int x=0,int y);
5、一个函数带有参数说明时，则参数的默认值应该在（ ）中给出。
A、函数定义
B、函数声明
C、函数定义或声明
D、函数调用
6、下列关于函数参数默认值的描述中，正确的是：
A、函数参数的默认值只能设置一个
B、若一个函数含有多个参数，其中一个参数设置成默认值后，其后所有参数都必须 设置默认值
C、若一个函数含有多个参数，则设置默认参数时可以不连续设置默认值
D、C++语言中函数都必须设有默认值
7、模板函数的真正代码是在（ ）时候产生。
A、源程序中声明函数时
B、源程序中定义函数时
C、源程序中的调用函数时
D、运行执行函数时
8、以下关于函数模板叙述正确的是：
A、函数模板也是一个具体类型的函数
B、函数模板的类型参数与函数的参数是同一个概念
C、通过使用不同的类型参数，函数模板可以生成不同类型的函数
D、用函数模板定义的函数没有类型
9、常情况下，函数模板中的类型参数个数不能是：
A、0
B、1
C、2
D、3
10、实现两个相同类型数加法的函数模板的声明是：
A、add(T x,T y)
B、T add(x,y)
C、T add(T x,y)
D、T add(T x,T y)
第11讲 函数的调用
第11讲 掌握函数的嵌套调用和递归调用
1、在参数传递过程中，对形参和实参的要求是：
A、函数定义时，形参一直占用存储空间
B、实参可以是常量、变量或表达式
C、形参可以是常量、变量或表达式
D、形参和实参类型和个数都可以不同
2、在函数的引用调用时，实参和形参应该是使用：
A、变量值和变量
B、地址值和指针
C、地址值和引用
D、变量值和引用
3、使用值传递方式将实参传给形参，下列说法正确的是：
A、形参是实参的备份
B、实参是形参的备份
C、形参和实参是同一对象
D、形参和实参无联系
4、下列函数调用中对调用它的函数没有起到任何作用的是：
A、void f1(double &x){ --x;}
B、double f2(double x){ return x-1.5;}
C、void f3(double x){ --x;}
D、double f4(double *x){ --*x;return *x;}
5、对于某个函数调用，不给出调用函数的声明的情况是：
A、被调用函数是无参函数
B、被调用函数是无返回值的函数
C、函数的定义在调用处之前
D、函数的定义有别的程序文件中
6、在哪种情况下适宜采用 inline 定义内联函数？
A、函数体含有循环语句
B、函数体含有递归语句
C、函数代码少、频繁调用
D、函数代码多、不常调用
7、下列哪个类型函数不适合声明为内联函数：
A、函数体语句较多
B、函数体语句较少
C、函数执行时间较短
D、函数执行时间过长
8、在C++中，编写一个内联函数Fsqu，使用double类型的参数，求其平方并返回，返回值为double类型，下列定义正确的是：
A、double Fsqu (double x){ return x*x;}
B、inline double Fsqu (double x){ return x*x;}
C、double inline Fsqu (double x){ return x*x;}
D、double Fsqu (double x){ inline return x*x;}
9、已知递归函数f的定义如下： int f(int n) { if (n<=1) return 1; else return n*f(n-2); } 则函数调用语句f（5）的返回值是：
A、14
B、15
C、16
D、17
10、在一个函数体中直接或间接地调用函数本身，这种调用称为（）调用。
A、嵌套
B、递归
C、直接
D、间接
第12讲 作用域、生命期和程序的组织结构
第12讲 理解作用域、生命期和程序的组织结构
1、不能实现函数之间数据传递的是：
A、全局变量
B、局部变量
C、函数接口
D、函数返回值
2、所有在函数中定义的变量，连同形式参数，都是：
A、全局变量
B、局部变量
C、静态变量
D、寄存器变量
3、内部静态变量的作用域是：
A、定义该静态变量的函数外部
B、定义该静态变量的函数内部
C、定义该静态变量的文件外部
D、定义该静态变量的文件内部
4、进行初始化即可自动获取初值为0的变量是：
A、任何用static修饰的变量
B、任何在函数外定义的变量
C、局部变量和用static修饰的全局变量
D、全局变量和用static修饰的局部变量
5、在函数中，可以用auto,extern，register和static四个关键字中的一个来说明变量的存储类型，如果不说明存储类型，则默认的存储类型是：
A、auto
B、extern
C、register
D、static
6、在一个C++源程序文件中定义的全局变量的有效范围是：
A、该C++程序的所有源程序文件
B、本源程序文件的全部范围
C、从定义变量的位置开始到本源程序文件结束
D、函数内部全部范围
7、在C++中有以下4条语句： static int hot=200; int &rad=hot; hot=hot+100; cout<<rad<<endl; 执行这4条语句后输出为：
A、0
B、100
C、200
D、300
8、下面关于C++语言变量的叙述错误的是：
A、C++语言中变量为auto，static，extern和register四种存储类型
B、自动变量和外部变量的作用域为整个程序
C、内部静态变量的作用域是定义它的函数
D、外部静态变量的作用域是定义它的文件
9、如果在一个源文件中定义的函数，只能被本文件中的函数调用，而不能被同一程序其它文件中的函数调用，则说明这个函数为：
A、私有函数
B、内部函数
C、外部函数
D、库函数
10、重新定义标识符的作用域规定是外层变量被隐藏，（）变量是可见的。
A、外层
B、内层
C、外层和内层
D、内部
第13讲 数组的定义和使用
第13讲 掌握数组的定义和使用
1、下列关于数组的描述正确是：
A、数组的长度是固定的，而其中元素的数据类型可以不同
B、数组的长度是固定的，而其中元素的数据类型必须相同
C、数组的长度是可变的，而其中元素的数据类型可以不同
D、数组的长度是可变的，而其中元素的数据类型必须相同
2、在C++语言中引用数组元素时，下面关于数组下标数据类型的说法错误的是：
A、整型常量
B、整型表达式
C、整型常量或整型表达式
D、任何类型的表达式
3、要定义数组A，使得其中每个元素的数据分别依次为：3、9、4、8、0、0、0，错误的定义语句是：
A、int A[]={ 3,9,4,8,0,0,0};
B、int A[9]={ 3,9,4,8,0,0,0};
C、int A[]={ 3,9,4,8};
D、int A[7]={ 3,9,4,8};
4、有如下数组声明：int value[30];，下标值引用错误的是：
A、value[30]
B、value[0]
C、value[10]
D、value[20]
5、以下叙述中错误的是：
A、对于double类型数组，不可以直接用数组名对数组进行整体输入或输出
B、数组名代表的是数组所占存储区的首地址，其值不可改变
C、当程序执行中，数组元素的下标超出所定义的下标范围时，系统将给出“下标越界”的出错信息
D、可以通过赋初值的方式确定数组元素的个数
6、以下正确的二维数组定义是：
A、int a[][]={ 1,2,3,4,5,6};
B、int a[2][]={ 1,2,3,4,5,6};
C、int a[][3]={ 1,2,3,4,5,6};
D、int a[2,3]={ 1,2,3,4,5,6};
7、以下对二维数组a进行初始化正确的是：
A、int a[2][]={ { 1,0,1},{ 5,2,3}} ;
B、int a[][3]={ { 1,2,3},{ 4,5,6}} ;
C、int a[2][4]={ { 1,2,3},{ 4,5},{ 6}} ;
D、int a[][3]={ { 1,0,1},{ },{ 1,1}} ;
8、若有定义：int a[3][4];则正确引用数组a元素的是：
A、a[2][4]
B、a[3][3]
C、a[0][0]
D、a[3][4]
9、若有定义：int a[][4]={ 0,0};以下叙述中错误的是：
A、数组a的每个元素都可得到初值0
B、二维数组a的第一维大小为1
C、因为初值个数除以a中第二维大小的值的商为0，故数组a的行数为1
D、只有元素a[0][0]和a[0][1]可得到初值0，其余元素均得不到初值0
10、下面选项中等价的是：
A、int a[2][3]={ 1,0,2,2,4,5}与int a[2][]= { 1,0,2,2,4,5};
B、int a[][3]= { 1,0,2,2,4,5}与int a[2][3]= { 1,0,2,2,4,5};
C、int a[2][3]={ 3,4,5}与int a[][3]={ 3,4,5};
D、int a[2][3]={ 0,1}与int a[2][3]={ { 0},{ 1}};
第14讲 数组与函数
第14讲 掌握数组作为函数参数的使用方法
1、若用数组名作为函数调用的实参，传递给形参的是：
A、数组的首地址
B、数组中第一个元素的值
C、数组中的全部元素的值
D、数组元素的个数
2、对数组名作函数的参数，下面描述正确的是：
A、数组名作函数的参数，调用时将实参数组复制给形参数组
B、数组名作函数的参数，主调函数和被调函数共用一段存储单元
C、数组名作参数时，形参定义的数组长度不能省略
D、数组名作参数，不能改变主调函数中的数据
3、已知某函数的一个形式参数被说明为MAT[3][10]，在下列说明中，与此等效的形参说明是：
A、int MAT[][10]
B、int MAT[3][]
C、int MAT[10][3]
D、int MAT[][]
4、设主调用函数为如下程序段，则函数f中对形参数组定义错误的是： int a[3][4]; f(a);
A、f(int array[3][4])
B、f(int array[][4])
C、f(int array[3][])
D、f(int array[4][3])
5、下面程序执行后的输出结果是： #include <iostream> using namespace std; int f(int b[],int m,int n) { int i,s=0; for(i=m;i<n;i++) s=s+b[i-1]; return s; } int main() { int x,a[]={ 1,2,3,4,5,6,7,8,9}; x=f(a,3,7); cout<<x; return 0; }
A、10
B、18
C、8
D、15
6、下面程序执行后的输出结果是： #include <iostream> using namespace std; #define N 20 void fun(int a[],int n,int m) { int i; for(i=m;i>=n;i--) a[i+1]=a[i]; } int main() { int i; int a[N]={ 1,2,3,4,5,6,7,8,9,10}; fun(a,2,9); for(i=0;i<5;i++) cout<<a[i]; return 0; }
A、10234
B、12344
C、12334
D、12234
7、下面程序执行后的输出结果是： #include <iostream> using namespace std; void swap1(int c[]) { int t; t=c[0];c[0]=c[1];c[1]=t; } void swap2(int c0,int c1) { int t; t=c0;c0=c1;c1=t; } int main( ) { int a[2]={ 3,5},b[2]={ 3,5}; swap1(a) ; swap2(b[0],b[1]); cout<<a[0] <<a[1] <<b[0] <<b[1]; return 0; }
A、5353
B、5335
C、3535
D、3553
8、下面程序执行后的输出结果是： #include <iostream> using namespace std; int fun(int t[],int n) { int m; if(n>=2) { m=fun(t,n-1); return m; } return t[0]; } int main() { int a[]={ 11,4,6,3,8,2,3,5,9,2}; cout<<fun(a,10); return 0; }
A、10
B、11
C、12
D、13
第15讲 字符串的处理
第15讲 掌握C和C++的字符串处理方式
1、字符串的长度是：
A、串中不同字符的个数
B、串中不同字母的个数
C、串中所含字符的个数且字符个数大于0
D、串中所含字符的个数
2、下列说法正确的是：
A、字符型数组与整型数组可通用
B、字符型数组与字符串其实没什么区别
C、当字符串放在字符数组中，这时要求字符数组长度比字符串长1个单元，因为要 放字符串终结符’\0’
D、字符串的输出可以用它所存储的数组来输出，也可以字符串的形式整体输出，结 果没区别
3、下面有关字符数组的描述中错误的是：
A、字符数组可以存放字符串
B、字符串可以整体输入、输出
C、可以在赋值语句中通过赋值运算对字符数组整体赋值
D、不可以用关系运算符对字符数组中的字符串进行比较
4、给出下面定义： char a[]=”abcd”; char b[]={ ‘a’,’b’,’c’,’d’}; 则下列说法正确的是：
A、数组a与数组b等价
B、数组a和数组b的长度相同
C、数组a的长度大于数组b的长度
D、数组a的长度小于数组b的长度
5、下面程序输出结果为： #include<iostream> using namespace std; #include<string.h> int main( ) { char st[20]="hello\0\t\\"; cout<<strlen(st); cout<<sizeof(st)<<endl; cout<<st; return 0; }
A、520 hello
B、1220 hello\0\t
C、520 hello\t
D、1120 hello└┘└┘
6、要使字符串变量str具有初值"Lucky"，正确的定义语句是：
A、char str[]={ 'L','u','c','k','y'};
B、char str[5]={ 'L','u','c','k','y'};
C、char str []="Lucky";
D、char str [5]="Lucky";
7、下列是为字符数组赋字符串的语句组，其中错误是：
A、char s[10]; s=”program”;
B、char s[]=”program”;
C、char s[10]=”Hello!”;
D、char s[10];strcpy(s,”hello!”);
8、字符数组s不能作为字符串使用的是：
A、char s[]="happy";
B、char s[6]={ 'h','a','p','p','y',''};
C、char s[]={ "happy"};
D、char s[5]={ 'h','a','p','p','y'};
9、下面程序段执行后的输出结果是： char c[5]={ 'a','b','','c',''}; cout<<c;
A、'a''b'
B、ab
C、ab c
D、abc
10、下面程序执行后的输出结果是： #include <iostream> using namespace std; #include<string.h> int main() { char str[]=" SSWLIA" , c; int k; for (k=2;(c=str[k])!='\0';k++) { switch (c) { case 'I': ++k; break ; case 'L': continue; default : cout<<c; continue ; } cout<<'*'; } return 0; }
A、SSW
B、SW*
C、SW*A
D、SW
第17讲 指针的定义与使用
第17讲 理解指针的定义，掌握指针的使用方法
1、下面对于指针的描述不正确的是：
A、指针是地址变量
B、指针不能用除0以外的常量赋值
C、两个指针变量的加法无意义
D、指针指向不同基类型的变量长度不同
2、在int a=3,int *p=&a；中，*p的值是：
A、变量a的地址值
B、无意义
C、变量p的地址值
D、3
3、已知int a, *pa=&a;输出指针pa十进制的地址值的方法是：
A、cout<<pa;
B、cout<<*pa;
C、cout<<&pa;
D、cout<<long(&pa);
4、变量的指针，其含义是指该变量的：
A、值
B、地址
C、名
D、一个标志
5、已有定义int k=2;int *ptr1,*ptr2;且ptr1和ptr2均已指向变量k，下面不能正确执行的赋值是：
A、k=*ptr1+*ptr2
B、ptr2=k
C、ptr1=ptr2
D、k=*ptr1*(*ptr2)
6、若有int *p,a=4;和p=&a;下面那个选项均代表地址？
A、a,p,*&a
B、&*a,&a,*p
C、*&p,*p,&a
D、&a,&*p,p
7、若变量已正确定义并且指针p已经指向变量x,则*&x相当于：
A、x
B、p
C、&x
D、&*p
8、若定义了int m,n=0,*p1=&m;则下列哪个表达式与m=n等价。
A、m=*p1
B、*p1=&*n
C、*&p1=&*n
D、*p1=*&n
9、假如指针p已经指向整型变量x，则(*p)++相当于：
A、x++
B、p++
C、*(p++)
D、&x++
10、对于基类型相同的两个指针变量之间，不合理的运算是：
A、<
B、=
C、+
D、-
第18讲 指针与数组
第18讲 掌握指针对一维数组的操作
1、以下四种说法中，正确的一项是：
A、C++允许在字符串上进行整体操作
B、语句：char vn[]=”Brown”; 将vn定义成一个有5个元素的数组，因为”Brown”中含有5个字符
C、对指针只要赋给一个地址值就可以了
D、一维的指针数组实际上是一个二维数组
2、定义如下一维数组：int a[5],*p=a;则下面描述错误的是：
A、表达式p=p+1是合法的
B、表达式a=a+1是合法的
C、表达式p-a是合法的
D、表达式a+2是合法的
3、若有语句int a[10]={ 0,1,2,3,4,5,6,7,8,9},*p=a；则哪个不是对a数组元素的正确引用（其中0≤i<10）。
A、p[i]
B、*(*(a+i))
C、a[p-a]
D、*(&a[i])
4、有如下程序段： int *p,a[6]={ -1,0,1,2,3,4}; p=a+3; 执行该程序段后，*p的值为：
A、4
B、2
C、1
D、NULL
5、若有定义 char s[10];则在下面表达式中不表示s[1]的地址的是：
A、s+1
B、s++
C、&s[0]+1
D、&s[1]
6、若要对a进行合法的自减运算，则之前应有下面哪个说明？
A、int p[3]; int *a=p;
B、int k; int *a=&k;
C、char *a[3];
D、int b[10]; int *a=b+1;
7、若有定义int x[10]={ 0,1,2,3,4,5,6,7,8,9},*p1;则数值不为3的表达式是:
A、x[3]
B、p1=x+3,*p1++
C、p1=x+2,*(p1++)
D、p1=x+2,*++p1
8、若有定义int x[6]={ 2,4,6,8,5,7},*p=x,i;要求依次输出x数组6个元素中的值，不能完成此操作的语句是:
A、for(i=0;i<6;i++) cout<<setw(2)<<*(p++);
B、for(i=0;i<6;i++) cout<<setw(2)<<*(p+i);
C、for(i=0;i<6;i++) cout<<setw(2)<<*p++);
D、for(i=0;i<6;i++) cout<<setw(2)<<(*p)++;
9、下面程序执行后的输出结果是: #include <iostream> using namespace std; void sum(int *a) { a[0]=a[1];} int main() { int aa[10]={ 1,2,3,4,5,6,7,8,9,10},i; for(i=2;i>=0;i--) sum(&aa[i]); cout<<aa[0]; return 0; }
A、1
B、2
C、3
D、4
10、下面程序执行后的输出结果是: #include <iostream> using namespace std; int main() { int a[10]={ 1,2,3,4,5,6,7,8,9,10}, *p=&a[3], *q=p+2; cout<<*p+*q; return 0; }
A、16
B、10
C、8
D、6
第19讲 指针与函数
第19讲 掌握指针作为函数参数的用法以及指向函数的指针
1、下面程序执行后的输出结果是： #include <iostream> using namespace std; void fun(char *c,char d) { *c=*c+1; d=d+1; cout<<*c<<","<<d<<","; } int main() { char a='A', b='a'; fun(&b,a); cout<<a<<","<<b<<endl; return 0; }
A、B,a,B,a
B、a,B,a,B
C、A,b,A,b
D、b,B,A,b
2、下面程序执行后的输出结果是: #include <iostream> using namespace std; void ss(char *s,char t) { while(*s) { if(*s==t) *s=t-'a'+'A'; s++; } } int main() { char str1[100]="abcddfefdbd",c='d'; ss(str1,c); cout<<str1; return 0; }
A、ABCDDEFEDBD
B、abcDDfefDbD
C、abcAAfefAbA
D、Abcddfefdbd
3、以下函数的功能是: fun(char *a,char *b) { while((*a!='\0')&&(*b!='\0')&&(*a==*b)) { a++;b++;} return(*a-*b); }
A、计算a和b所指字符串的长度之差
B、将b所指字符串连接到a所指字符串中
C、将a所指字符串连接到b所指字符串后面
D、比较a和b所指字符串的大小
4、若有定义char *st="how are you";下列程序段中正确的是:
A、char a[11],*p; strcpy(p=a+1,&st[4]);
B、char a[11]; strcpy(++a, st);
C、char a[11]; strcpy(a, st);
D、char a[],*p; strcpy(p=&a[1],st+2);
5、以下与库函数strcpy(char *p1,char *p2)功能不相等的程序段是:
A、strcpy1(char *p1,char *p2) { while ((*p1++=*p2++)!='\0') ; }
B、strcpy2(char *p1,char *p2) { while ((*p1=*p2)!='\0') { p1++; p2++ } }
C、strcpy3(char *p1,char *p2) { while (*p1++=*p2++) ; }
D、strcpy4(char *p1,char *p2) { while (*p2) *p1++=*p2++ ; }
6、函数char* fun(char *p){ return p; }的返回值是:
A、无确切的值
B、形参p中存放的地址值
C、一个临时存储单元的地址
D、形参p自身的地址值
7、若有定义int *f();中，标识符f代表的是:
A、一个用于指向整型数据的指针变量
B、一个用于指向一维数组的行指针
C、一个用于指向函数的指针变量
D、一个返回值为指针型的函数名
8、若有定义int(*p)();标识符p可以:
A、表示函数的返回值
B、指向函数的入口地址
C、表示函数的返回类型
D、表示函数名
9、若有函数max(a,b)，为了让函数指针变量p指向函数max，正确的赋值方法是:
A、p=max;
B、p=max(a,b);
C、*p=max;
D、*p=max(a,b);
10、若有以下说明和定义： int fun(int *c) { ……} int main() { int (*a)(int *)=fun,*b,w[10],c; …… } 在必要的赋值之后，对fun函数的正确调用语句是:
A、a=a(w);
B、a(&c);
C、b=*b(w);
D、fun(*b);
第20讲 动态分配内存
第20讲 掌握动态分配内存的方法
1、对使用关键字new所开辟的动态存储空间，释放时必须使用：
A、free
B、create
C、delete
D、realse
2、关于动态存储分配，下列说法正确的是：
A、new和delete是C++语言中专门用于动态内存分配和释放的函数
B、动态分配的内存空间也可以被初始化
C、当系统内存不够时，会自动回收不再使用的内存单元，因此程序中不必使用 delete释放内存空间
D、当动态分配内存失败时，系统会立刻崩溃，因此一定要慎用new
3、对new运算符的下列描述中，哪个是错误的？
A、它可以动态创建对象和对象数组
B、用它创建对象数组时必须指定初始值
C、用它创建对象时要调用构造函数
D、用它创建的对象可以使用运算符delete来释放
4、若有以下定义，则释放指针所指内存空间的操作是： float *r=new float[10];
A、delete r ;
B、delete *r;
C、delete []r;
D、delete r[];
5、已知n是一个int型变量，下列语句中错误的是:
A、long *p=new long[n];
B、long p[n];
C、long *p=new long(n);
D、long p[10];
第21讲 自定义数据类型
第21讲 掌握三种自定义数据类型
1、设有结构体说明 struct ex { int x; float y; char z;} example;以下叙述中错误的是：
A、struct是结构体类型的关键字
B、example是结构体类型名
C、x,y,z都是结构体成员名
D、struct ex是结构体类型
2、以下哪个定义不会分配实际的存储空间？
A、struct { char name[10] ; int age ; } student ;
B、struct STUDENT { char name[10] ; int age ; } student ;
C、struct STUDENT { char name[10] ; int age ; } ; struct STUDENT student;
D、struct STUDENT { char name[10] ; int age ; } ;
3、在说明一个结构体变量时，系统分配给它的存储空间是：
A、该结构体中的第一个成员所需的存储空间
B、该结构体中的最后一个成员所需的存储空间
C、该结构体中占用最大存储空间的成员所需的存储空间
D、该结构体中所有成员所需存储空间的总和
4、已知学生记录描述为： struct student { int no ; char name[20]; char sex; struct { int year; int month ; int day ; } birth; } s; 设结构变量s中的“birth”应是“1985年10月1日”，则下面正确的赋值是：
A、year=1985; month=10; day=1;
B、birth.year=1985; birth.month=10; birth.day=1;
C、s.year=1985; s.month=10; s.day=1;
D、s.birth.year=1985; s.birth.month=10; s.birth.day=1;
5、设有定义struct ru{ long x;float y;} time,*timep=&time;则对time中成员x的正确引用是：
A、ru.time.x
B、timep.x
C、(*timep).x
D、time->x
6、有以下说明和定义： union dt { int a;char b;double c; } data; 以下叙述中错误的是：
A、data的每个成员起始地址都相同
B、变量data所占的内存字节数与成员c所占字节数相等
C、程序段：data.a=5;cout<<data.c;输出结果为5.000000
D、data可以作为函数的实参
7、若有定义union data { char ch;int x;} a;下列语句中哪个是不正确的？
A、a={ 'x',10}
B、a.x=10;a.x++;
C、a.ch='x';a.ch++;
D、a.x=10;a.ch='x';
8、若有定义enum color { red,yellow=2,blue,white,black} r=white;执行cout<<r;后的输出结果是：
A、1
B、2
C、3
D、4
9、下面对typedef的叙述中错误的是：
A、用typedef可以定义各种类型名，但不能用来定义变量
B、用typedef可以增加新类型
C、用typedef只是将已存在的类型用一个新的标识符来代表
D、使用typedef有利于程序的通用和移植
10、若有定义typedef struct { int n;char ch[8];} PER;以下叙述中正确的是：
A、PER是结构体变量名
B、PER是结构体类型名
C、typedef struct 是结构体类型
D、struct 是结构体类型名
第22讲 自定义数据类型的应用——链表
第22讲 掌握链表的结构和使用
1、链表不具有的特点是：
A、可随机访问任一元素
B、插入、删除不需要移动元素
C、不必事先估计存储空间
D、所需空间与结点个数成正比
2、链表结点所占存储空间：
A、分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针
B、只有一部分，存放结点值
C、只有一部分，存储表示结点间关系的指针
D、分两部分，一部分存放结点值，另一部分存放结点所占单元数
3、有以下结构体说明和变量的定义，且指针p指向变量a,指针q指向变量b，则不能把结点b连接到结点a之后的语句是： struct node { char data; struct node *next; } a,b,*p=&a,*q=&b;
A、a.next=q;
B、p.next=&b;
C、p->next=&b;
D、(*p).next=q;
4、在单向链表中，存储每个结点需有两个域，一个是数据域，另一个是指针域，它指向该结点的：
A、直接前趋
B、直接后继
C、开始结点
D、终端结点
5、对于一个头指针为head的带头结点的单向链表，判定该表为空表的条件是：
A、head==NULL
B、head→next==NULL
C、head→next==head
D、head!=NULL
6、有以下结构体说明和变量定义，如图所示： struct node { int data; struct node *next; } *p, *q, *r; 现要将q所指结点从链表中删除，同时要保持链表的连续，以下不能完成指定操作的语句是：
A、p->next=q->next;
B、p->next=p->next->next;
C、p->next=r;
D、p=q->next;
7、有以下定义： struct link { int data; struct link *next; } a,b,c,*p,*q; 且变量a和b之间已有如下图所示的链表结构： 指针p指向变量a，q指向变量c。则能够把c插入到a和b 之间并形成新的链表的语句组是：
A、a.next=c; c.next=b;
B、p.next=q; q.next=p.next;
C、p->next=&c; q->next=p->next;
D、(*p).next=q; (*q).next=&b;
8、有关双向链表的说法正确的是：
A、双向链表实现了对结点的随机访问，是一种随机存储结构
B、双向链表的结点含有两个指针域，分别存放其直接前趋和直接后继结点的地址
C、双向链表所需空间与单向链表相同
D、在双向链表中插入或删除结点时，需要移动结点
9、链表是一种采用（ ）存储结构存储的线性表。
A、顺序
B、链式
C、星式
D、网状
10、下面程序执行后的输出结果是： #include <iostream> #include <cmath> using namespace std; struct NODE { int num; struct NODE *next; }; int main() { struct NODE *p,*q,*r; p=new NODE; q=new NODE; r=new NODE; p->num=10; q->num=20; r->num=30; p->next=q;q->next=r; cout<<p->num+q->next->num<<endl; return 0; }
A、10
B、20
C、30
D、40
第23讲 预处理命令
第23讲 掌握预处理命令的使用
1、以下叙述中错误的是：
A、预处理命令行都必须以#开始
B、在程序中凡是以#开始的语句行都是预处理命令行
C、C++程序在执行过程中对预处理命令行进行处理
D、预处理命令行可以出现在C++程序中任意一行上
2、设#define P(x) x/x执行语句cout <<P(3*5);后的输出结果是：
A、1
B、0
C、25
D、15
3、在任何情况下计算平方都不会引起二义性的宏定义是：
A、#define POWER(x) x*x
B、#define POWER(x) (x)*(x)
C、#define POWER(x) (x*x)
D、#define POWER(x) ((x)*(x))
4、下面程序执行后的输出结果是： #include <iostream> using namespace std; #define A 3 #define B 2*A #define C B+A int main() { int a=B; cout<<C<<"└┘"<<--a<<endl; return 0; }
A、9└┘5
B、2└┘3
C、9└┘3
D、7└┘5
5、若有宏定义： #define N 3 #define Y(n) ((N+1)*n) 则表达式2*(N+Y(5+1))的值是：
A、出错
B、42
C、48
D、54
6、已知宏定义#define p(x,y,z) x=y*z;则宏替换p(a,x+5,y－3.1)应为：
A、a=x+5*y－3.1;
B、a=(x+5)*(y－3.1);
C、a=x+5*y－3.1
D、a=(x+5)*(y－3.1)
7、下面程序执行后的输出结果是： #include <iostream> using namespace std; #define MA(x) x*x-1 int main() { int a=1,b=2; cout<<MA(1+a+b); return 0; }
A、6
B、8
C、10
D、12
8、下面程序执行后的输出结果是： #include <iostream> using namespace std; #define R 0.5 #define AREA(x) R*x*x int main() { int a=1, b=2; cout<<AREA(a+b); return 0; }
A、0.0
B、0.5
C、3.5
D、4.5
9、在“文件包含”预处理命令形式中，当#include后面的文件名用" "（双引号）括起时，寻找被包含文件的方式是：
A、直接按系统设定的标准方式搜索目录
B、先在源程序所在目录中搜索，再按系统设定的标准方式搜索
C、仅仅搜索源程序所在目录
D、仅仅搜索当前目录
10、在“文件包含”预处理命令形式中，当#include后面的文件名用< >（尖括号）括起时，寻找被包含文件的方式是：
A、直接按系统设定的标准方式搜索目录
B、先在源程序所在目录中搜索，再按系统设定的标准方式搜索
C、仅仅搜索源程序所在目录
D、仅仅搜索当前目录
第25讲 类的定义
第25讲 掌握类的基本概念
1、下面关于类中概念的描述中错误的是：
A、类是抽象数据类型的实现
B、类是具有共同行为的若干对象的统一描述体
C、类是创建对象的样板
D、类就是C语言中的结构体类型
2、下列关于C++语言类的描述中错误的是：
A、类用于描述事物的属性和对事物的操作
B、类与类之间通过封装而具有明确的独立性
C、类与类之间必须是平等的关系，而不能组成层次结构
D、类与类之间可以通过一些方法进行通信和联络
3、在面向对象设计中，对象有很多基本特点，其中“一个系统中通常包含很多类，这些类之间呈树形结构”这一性质指的是对象的：
A、分类性
B、标识唯一性
C、继承性
D、封装性
4、什么是成员：
A、类的特征
B、类的方法
C、类的事件
D、以上全是
5、作用域运算符的功能是：
A、标识作用域的级别
B、指出的大小
C、标识某个成员是属于哪一类的
D、给出的范围
第26讲 对象的定义和使用
第26讲 掌握 对象的定义和使用
1、假定AA为一个类，a()为该类公有的函数成员，x为该类的一个对象，则访问x对象中函数成员a()的格式为：
A、x.a
B、x.a()
C、x->a
D、x->a()
2、为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为：
A、public
B、protected
C、private
D、static
3、在用关键字class定义的类中，以下叙述正确的是：
A、在类中，不作特别说明的数据成员均为私有类型
B、在类中，不作特别说明的数据成员均为公有类型
C、类成员的定义必须是成员变量定义在前，成员函数定义在后
D、类的成员定义必须放在类定义体内部
4、下列关于成员函数特征的描述中，错误的是：
A、成员函数一定是内联函数
B、成员函数可以重载
C、成员函数可以设置参数的默认值
D、成员函数可以是静态的
5、下列有关类的说法不正确的是：
A、对象是类的一个实例
B、任何一个对象只能属于一个具体的类
C、一个类只能有一个对象
D、类与对象的关系和数据类型与变量的关系相似
第27讲 构造函数
第27讲 掌握构造函数的功能和使用方法
1、类的构造函数被自动调用执行的情况是在定义该类的：
A、成员函数时
B、数据成员时
C、对象时
D、友元函数时
2、设类A将其它类对象作为成员，则建立A类对象时，下列描述正确的是：
A、类构造函数先执行
B、成员构造函数先执行
C、两者并行执行
D、不能确定
3、假定一个类的构造函数为“A(int aa=1, int bb=0) { a=aa; b=bb;}”, 则执行“A x (4);”语句后，x.a和x.b的值分别为：
A、1和0
B、1和4
C、4和0
D、4和1
4、下列是构造函数的特点，是错误的是：
A、构造函数是一种成员函数，它具有一般成员函数的特点
B、构造函数的名称与其类名相同
C、构造函数必须指明其类型
D、一个类中可定义一个或多个构造函数
5、构造函数不具备的特征的是：
A、构造函数的函数名与类名相同
B、构造函数可以重载
C、构造函数可以设置默认参数
D、构造函数必须指定类型说明
第28讲 默认构造函数和复制构造函数
第28讲 掌握默认构造函数和复制构造函数的使用法则
1、假定AB为一个类，则执行AB x(y)；语句时将自动调用该类的：
A、有参构造函数
B、无参构造函数
C、复制构造函数
D、赋值构造函数
2、通常，复制构造函数的参数是：
A、某个对象名
B、某个对象的成员名
C、某个对象的引用名
D、某个对象的指针名
3、类的默认的复制构造函数：
A、在任何情况下都存在
B、仅当未定义复制构造函数时存在
C、仅当未定义有参构造函数时存在
D、仅当未定义任何构造函数时存在
4、下列情况中，不会调用复制构造函数的是：
A、用一个对象去初始化同一类的另一个新对象时
B、将类的一个对象赋值给该类的另一个对象时
C、函数的形参是类的对象，调用函数进行形参和实参相结合
D、函数的返回值是类的对象，函数执行返回调用时
5、假设OneClass为一个类，则该类的复制初始化构造函数的声明语句为：
A、OneClass(OneClass p);
B、OneClass& (OneClass p);
C、OneClass(OneClass & p);
D、OneClass (OneClass *p);
第29讲 析构函数
第29讲 掌握析构函数的用途和使用方法
1、下面有关类说法不正确的是：
A、一个类可以有多个构造函数
B、一个类只有一个析构函数
C、析构函数需要指定参数
D、在一个类中可以说明具有类类型的数据成员
2、对类的构造函数和析构函数描述正确的是：
A、构造函数可以重载，析构函数不能重载
B、构造函数不能重载，析构函数可以重载
C、构造函数可以重载，析构函数也可以重载
D、构造函数不能重载，析构函数也不能重载
3、类的析构函数的作用是：
A、一般成员函数
B、类的初始化
C、对象初始化
D、撤销对象时要执行的操作
4、下面哪项是对构造函数和析构函数的正确定义？
A、X::X(参数), X::~X()
B、X::X(参数), X::~X(参数)
C、void X::X(参数), void X::~X(参数)
D、void X::X(), void X::~X()
5、以下有关析构函数的叙述不正确的是：
A、析构函数没有任何函数类型
B、析构函数的作用是在对象被撤销时收回先前分配的内存空间
C、析构函数可以有形参
D、一个类只有一个析构函数
第30讲 对象数组和对象指针
第30讲 对象数组和对象指针
1、有以下的类定义：class MyClass { public: MyClass(){ cout<<'1';} }; 则执行语句MyClass a,b[2],*p[2];后，程序的输出结果是（ ）。
A、11
B、111
C、1111
D、11111
2、已知p是一个指向类sample数据成员m的指针，s是类sample的一个对象。如果要给m赋值为5，哪个是正确的？
A、s.p=5
B、s->p=5
C、s.*p=5
D、*s.p=5
3、假定AA是一个类，“AA* abc()const;”是该类中一个成员函数的原型，若该函数返回this值，当用x.abc()调用该成员函数后，x的值：
A、已经被改变
B、可能被改变
C、不变
D、受到函数调用的影响
4、下列关于this指针的叙述中，正确的是：
A、this指针是一个隐含指针，它隐含于类的成员函数中
B、只有在使用this时，系统才会将对象的地址赋值给this
C、类的友元函数也有this指针
D、this指针表示了成员函数当前操作的数据所属的对象
5、this指针存在的目的是：
A、保证基类公有成员在子类中可以被访问
B、保证每个对象拥有自己的数据成员，但共享处理这些数据成员的代码
C、保证基类保护成员在子类中可以被访问
D、保证基类私有成员在子类中可以被访问
第31讲 类作用域、对象生命期、const限定
第31讲 掌握const成员的使用
1、定AA是一个类，“AA* abc()const;”是该类中一个成员函数的原型，若该函数返回this值，当用x.abc()调用该成员函数后，x的值：
A、已经被改变
B、可能被改变
C、不变
D、受到函数调用的影响
2、对于常数据成员，下面描述正确的是：
A、常数据成员可以不初始化，并且不能更新
B、常数据成员必须被初始化，并且不能更新
C、常数据成员可以不初始化，并且可以被更新
D、常数据成员必须被初始化，并且可以更新
3、下列不能作为类的成员的是：
A、自身类对象的指针
B、自身类对象
C、自身类对象的引用
D、另一个类的对象
第32讲 静态成员和友元
第32讲 掌握静态成员和友元的使用
1、静态数据成员的初始化必须在：
A、类内
B、类外
C、构造函数内
D、静态成员函数内
2、静态成员函数没有：
A、返回值
B、this指针
C、指针参数
D、返回类型
3、下列不是描述类的成员函数的是：
A、构造函数
B、析构函数
C、友元函数
D、复制构造函数
4、下面关于友元的描述中，错误的是：
A、友元函数可以访问该类的私有数据成员
B、一个类的友元类中的成员函数都是这个类的友元函数
C、友元可以提高程序的运行效率
D、类与类之间的友元关系可以继承
5、已知类A是类B的友元，类B是类C的友元，则：
A、类A一定是类C的友元
B、类C一定是类A的友元
C、类C的成员函数可以访问类B的对象的任何成员
D、类A的成员函数可以访问类B的对象的任何成员
第33讲 类的继承与派生
第33讲 掌握派生类的定义
1、定义新类是通过什么实现的
A、信息隐藏
B、数据封装
C、继承机制
D、数据抽象
2、继承具有（ ），即当基类本身也是某一个类派生类时，底层的派生类也会自动继承间接基类的成员
A、规律性
B、传递性
C、重复性
D、多样性
3、C++类体系中，不能被派生类继承的有：
A、构造函数
B、虚函数
C、静态成员函数
D、赋值操作函数
4、C++的继承性允许派生类继承基类的：
A、部分特性，并允许增加新的特性或重定义基类的特性
B、部分特性，但不允许增加新的特性或重定义基类的特性
C、所有特性，并允许增加新的特性或重定义基类的特性
D、所有特性，但不允许增加新的特性或重定义基类的特性
5、对基类和派生类的关系描述中，错误的是：
A、派生类是基类的具体化
B、基类继承了派生类的属性
C、派生类是基类定义的延续
D、派生类是基类的特殊化
第34讲 派生类成员的访问
第34讲 掌握派生类成员的访问方法
1、若要用派生类的对象访问基类的保护成员，以下观点正确的是：
A、可采用公有继承
B、可采用私有继承
C、可采用保护继承
D、不可能实现
2、派生类的对象对它的基类成员中（ ）是可以访问的？
A、公有继承的公有成员
B、公有继承的私有成员
C、公有继承的保护成员
D、私有继承的公有成员
3、下列说法中错误的是：
A、公有继承时基类中的public成员在派生类中仍是public成员
B、私有继承时基类中的protected成员在派生类中仍是protected成员
C、私有继承时基类的public成员在派生类中是private成员
D、保护继承时基类的public成员在派生类中是protected成员
4、下面叙述不正确的是：
A、派生类一般都用公有派生
B、基类成员的访问必须是无二义性的
C、赋值兼容规则也适用于多重继承的组合
D、基类的公有成员在派生类中仍然是公有的
5、若派生类的成员函数不能直接访问基类中继承来的某个成员，则该成员一定是基类中的：
A、私有成员
B、公有成员
C、保护成员
D、保护成员或私有成员
第35讲 派生类的构造和析构函数
第35讲 掌握派生类的构造和析构函数
1、有如下程序： #include <iostream> using namespace std; class Base{ protected: Base(){ cout<<'A';} Base(char c){ cout<<c;} }; class Derived:public Base{ public: Derived(char c){ cout<<c;} }; int main(){ Derived d1('B'); return 0; } 执行这个程序屏幕上将显示输出：
A、B
B、BA
C、AB
D、BB
2、派生类的构造函数的成员初始化列表中，不能包含：
A、基类的构造函数
B、派生类中子对象的初始化
C、基类中子对象的初始化
D、派生类中一般数据成员的初始化
3、假设ClassY:publicX，即类Y是类X的派生类，则说明一个Y类的对象时和删除Y类对象时，调用构造函数和析构函数的次序分别为：
A、X,Y,Y,X
B、X,Y,X,Y
C、Y,X,X,Y
D、Y,X,Y,X
4、以下有关继承的叙述正确的是：
A、构造函数和析构函数都能被继承
B、派生类是基类的组合
C、派生类对象除了能访问自己的成员以外，不能访问基类中的所有成员
D、基类的公有成员一定能被派生类的对象访问
5、建立包含有类对象成员的派生类对象时，自动调用构造函数的执行顺序依次为：
A、自己所属类、对象成员所属类、基类的构造函数
B、对象成员所属类、基类、自己所属类的构造函数
C、类、对象成员所属类、自己所属类的构造函数
D、基类、自己所属类、对象成员所属类的构造函数
第36讲 多重继承
第36讲 掌握多重继承的规则
1、下列关于多继承二义性的描述中，错误的是：
A、一个派生类的两个基类中都有某个同名成员，派生类中这个成员的访问可能出 现二义性
B、解决二义性的最常用的方法是对成员名的限定法
C、基类和派生类中同时出现的同名函数，也存在二义性问题
D、一个派生类是从两个基类派生出来的，而这两个基类又有一个共同的基类，对 该基类成员进行访问时，可能出现二义性
2、解决二义性问题的方法有：
A、只能使用作用域分辨操作符
B、使用作用域分辨操作符或赋值兼容规则
C、使用作用域分辨操作符或虚基类
D、使用虚基类或赋值兼容规则
3、假设类X以类Y作为它的一个基类，并且X类的名字func()支配Y类的名字func()，obj为类X的对象，则obj.func()语句实现的功能为：
A、先执行类X的func()，再执行访问类Y的func()
B、先执行类Y的func()，再执行访问类X的func()
C、执行类X的func()
D、执行类Y的func()
4、多重继承的构造顺序可分为如下四步： （1）所有非虚基类的构造函数按照他们被继承的顺序构造 （2）所有虚基类的构造函数按照他们被继承的顺序构造 （3）所有子对象的构造函数按照他们被继承的顺序构造 （4）派生类自己的构造函数体 这四个步骤的正确顺序是：
A、（4）（3）（2）（1）
B、（2）（4）（3）
