判断题26 分
1-1
所有运算符，即可以重载为类的成员函数，也可以重载为全局函数，并往往声明为友元函数。
T
F
| 参考答案
答案
F
1分
1-2
赋值运算符“ =”只能重载为成员函数。
T
F
| 参考答案
答案
T
1分
1-3
重载运算符()、[]、->或者=赋值运算符，运算符重载函数必须声明为类的成员函数。
T
F
| 参考答案
答案
T
1分
1-4
重载为成员函数时，参数个数比运算符的操作数个数少1个。
T
F
| 参考答案
答案
T
1分
1-5
若重载为友元函数，函数定义格式如下：
<类型>operator<运算符>（<参数列表>）
{
<函数体>
}
T
F
| 参考答案
答案
F
1分
1-6
若重载为成员函数，其定义如下：
<类型><类名>::operator<运算符>（<参数列表>）
{
<函数体>
}
T
F
| 参考答案
答案
T
1分
1-7
在C++中，只能重载C++预定义的运算符，不能创造新的运算符。
T
F
| 参考答案
答案
T
1分
1-8
函数的参数个数和类型都相同，只是返回值不同，这不是重载函数。
T
F
| 参考答案
答案
T
1分
1-9
重载函数可以带有默认值参数，但是要注意二义性。
T
F
| 参考答案
答案
T
1分
1-10
两个以上的函数，具有相同的函数名，且形参的个数或形参的类型不同，或返回的数据类型不同，则称之为函数的重载。
T
F
| 参考答案
答案
F
1分
1-11
在类的成员函数中，const关键字可以用作对重载函数的区分。
T
F
| 参考答案
答案
T
1分
1-12
对每个可重载的运算符来讲，它既可以重载为友元函数，又可以重载为成员函数，还可以重载为非成员函数。
T
F
| 参考答案
答案
F
1分
1-13
下面两个全局函数构成函数重载。
int Add(int a, int b) {return a+b;}
int Add(int x, int y) {return x-y;}。
T
F
| 参考答案
答案
F
1分
1-14
形参 int fun(int a=1,int b,int c=2)合法
T
F
| 参考答案
答案
F
1分
1-15
int Sum (int a,int b=5,int c); 这个函数原型的声明没有什么不合适的地方。
T
F
| 参考答案
答案
F
1分
1-16
#include
using namespace std;
int add(int x=4,int y=7)
{
return x+y;
}
int main()
{
cout<<add(3,6)<<endl;
cout<<add(3)<<endl;
cout<<add()<<endl;
}
则运行上述程序后，输出的结果为：
9
10
11
答案为T，分值为2分。
T
F
| 参考答案
答案
T
1分
1-17
带有默认值的函数F的函数原型为F(int x=5, int x=9, int y, float m=10.0)，则该函数在编译时会报错。答案为T，分值为2分。
T
F
| 参考答案
答案
T
1分
1-18
在C++语言中引入内联函数（inline function）的主要目的是降低空间复杂度，即缩短目标代码长度。
T
F
| 参考答案
答案
F
1分
1-19
主程序调用内联函数（inline）时，不发生控制转移，无需保存和恢复环境变量等，因此，节省了系统开销。内联函数的声明以及最终的生效，是由程序员决定的。
T
F
| 参考答案
答案
F
1分
1-20
对单目运算符重载为友元函数时，可以说明一个形参。而重载为成员函数时，不能显式说明形参。
T
F
| 参考答案
答案
T
1分
1-21
对于++运算符的重载，要求重载两种形式，一种是前置++，一种是后置++。
T
F
| 参考答案
答案
T
1分
1-22
多数运算符可以重载，个别运算符不能重载，运算符重载是通过函数定义实现的。
T
F
| 参考答案
答案
T
1分
1-23
重载运算符可以保持原运算符的优先级和结合性不变。
T
F
| 参考答案
答案
T
1分
1-24
重载关系运算符一般都返回true或false值。
T
F
| 参考答案
答案
T
1分
1-25
重载为成员函数时，参数个数为运算符数目减一。
T
F
| 参考答案
答案
T
1分
1-26
重载为友元函数时，参数个数为运算符数目。
T
F
| 参考答案
答案
T
1分
单选题58 分
2-1
若需要为xv类重载乘法运算符,运算结果为xv类型,在将其声明为类的成员函数时,下列原型声明正确的是_________。
A.
xv*(xv);
B.
operator*(xv);
C.
xv operator*(xv);
D.
xv operator*(xv,xv);
| 参考答案
答案
C
2分
2-2
如何区分自增运算符重载的前置形式和后置形式？
A.
重载时，前置形式的函数名是++operator，后置形式的函数名是operator ++
B.
后置形式比前置形式多一个 int 类型的参数
C.
无法区分，使用时不管前置形式还是后置形式，都调用相同的重载函数
D.
前置形式比后置形式多一个 int 类型的参数
| 参考答案
答案
B
2分
2-3
下列运算符中，（ ）运算符不能重载。
A.
＆＆
B.
[ ]
C.
::
D.
<<
| 参考答案
答案
C
2分
2-4
下列关于运算符重载的描述中，（ ）是正确的。
A.
运算符重载可以改变操作数的个数
B.
运算符重载可以改变优先级
C.
运算符重载可以改变结合性
D.
运算符重载不可以改变语法结构
| 参考答案
答案
D
2分
2-5
在C++中不能重载的运算符是
A.
?:
B.
+
C.
-
D.
<=
| 参考答案
答案
A
2分
2-6
下列关于运算符重载的表述中，正确的是（）。
A.
C++已有的任何运算符都可以重载
B.
运算符函数的返回类型不能声明为基本数据类型
C.
在类型转换符函数的定义中不需要声明返回类型
D.
可以通过运算符重载来创建C++中原来没有的运算符
| 参考答案
答案
C
2分
2-7
能用友元函数重载的运算符是（）。
A.
+
B.
=
C.
[]
D.
->
| 参考答案
答案
A
2分
2-8
下列关于运算符重载的描述中，（ ）是正确的。
A.
针对<<、>>运算符不可以采用友元函数进行重载
B.
针对<<、>>运算符既可以采用成员函数也可以采用友元函数进行重载
C.
AB说法均正确
D.
ABC均不正确
| 参考答案
答案
D
2分
2-9
下列哪一项说法是不正确的?
A.
运算符重载的实质是函数重载
B.
运算符重载可以重载为普通函数,也成员可以重载为成员函数
C.
运算符被多次重载时,根据实参的类型决定调用哪个运算符重载函数
D.
运算符被多次重载时,根据函数类型决定调用哪个重载函数
| 参考答案
答案
D
2分
2-10
下列关于运算符重载的描述正确的是（ ）。
A.
运算符重载可以改变操作数的个数
B.
可以创造新的运算符
C.
运算符可以重载为友元函数
D.
任意运算符都可以重载
| 参考答案
答案
C
2分
2-11
在重载一个运算符时，如果其参数表中有一个参数，则说明该运算符是( )。
A.
一元成员运算符
B.
二元成员运算符
C.
一元友元运算符
D.
二元成员运算符或一元友元运算符
| 参考答案
答案
D
2分
2-12
下列关于运算符重载的描述中，错误的是（）。
A.
运算符重载不改变优先级
B.
运算符重载后，原来运算符操作不可再用
C.
运算符重载不改变结合性
D.
运算符重载函数的参数个数与重载方式有关
| 参考答案
答案
B
2分
2-13
下列运算符中，不可以重载的是（ ）。
A.
new
B.
++
C.
.*
D.
[]
| 参考答案
答案
C
2分
2-14
关于智能指针，下述哪一种说法是错误的？
A.
智能指针有助于避免内存泄漏
B.
智能指针借助于引用计数来确定其所指向的对象的回收时机
C.
智能指针借助于操作符重载实现与普通指针类似的功能，包括-> 及 * 操作符
D.
智能指针既可以管理栈对象，也可以管理堆对象的生命周期
| 参考答案
答案
D
2分
2-15
下列关于运算符重载的描述中，错误的是（）。
A.
运算符重载后，原来运算符操作不可再用
B.
运算符重载不改变优先级
C.
运算符重载函数的参数个数与重载方式有关
D.
运算符重载不改变结合性
| 参考答案
答案
A
2分
2-16
重载函数在调用时选择的依据中，错误的是（）。
A.
函数的参数
B.
参数的类型
C.
函数的名字
D.
函数的类型
| 参考答案
答案
D
1分
2-17
对定义重载函数的下列要求中，（ ）是错误的。
A.
要求参数的个数不同
B.
要求参数中至少有一个类型不同
C.
要求函数的返回值不同
D.
要求参数个数相同时，参数类型不同
| 参考答案
答案
C
1分
2-18
一个函数为void f(int x, char y = ‘a’)，另一个函数为void f(int)，则它们____。
A.
不能在同一程序块中定义
B.
可以在同一个程序块中定义并可重载
C.
可以在同一个程序块中定义，但不可以重载
D.
以上说法均不正确
| 参考答案
答案
B
1分
2-19
下列关于函数重载的说法中，错误的是____。
A.
重载函数的参数个数不同
B.
重载函数参数类型不同
C.
重载函数的函数名必须相同
D.
重载函数的返回值类型不同
| 参考答案
答案
D
1分
2-20
以下有关函数的叙述中正确的是（ ）。
A.
函数必须返回一个值
B.
函数体中必须有return语句
C.
两个同名函数，参数表相同而返回值不同不算重载
D.
函数执行中形参的改变会改变实参
| 参考答案
答案
C
1分
2-21
重载函数在调用时选择的依据中，错误的是( )
A.
函数的参数
B.
参数的类型
C.
函数的名字
D.
函数的类型
| 参考答案
答案
D
1分
2-22
下面说法正确的是?
A.
多个重载函数的参数个数必须不同
B.
两个函数,参数表相同,返回值类型不同,它们是重载关系
C.
调用一个第二个和第三个参数都有缺省值的函数时,可以不写第二个实参而写第三个实参
D.
使用内联函数的目是提高程序运行速度
| 参考答案
答案
D
1分
2-23
在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是
A.
作为友元函数重载的1元运算符
B.
作为成员函数重载的1元运算符
C.
作为友元函数重载的2元运算符
D.
作为成员函数重载的2元运算符
| 参考答案
答案
B
1分
2-24
关于函数的重载
下面 4 组重载函数的声明中，▁▁▁▁▁ 是正确的。
A.
void F();
char F();
int F();
double F();
B.
void F(int a);
void F(int b);
void F(int c);
void F(int d);
C.
void F();
void F(int x);
void F(double x);
void F(int x, int y);
D.
void F();
void F(int x);
void F(int x, int y);
void F(int x = 0, int y = 0);
| 参考答案
答案
C
1分
2-25
下面叙述中正确的是( )。
A.
对于用户自己定义的函数，在使用前必须加以说明
B.
替换为错误项函数可以返回一个值，也可以什么值也不返回
C.
说明函数时必须明确其参数类型和返回类型
D.
空函数不完成任何操作，所以在程序设计中没有用处
| 参考答案
答案
C
1分
2-26
下面叙述中错误的是()。
A.
主函数中定义的变量在整个程序中都是有效的
B.
替换为在其他函数中定义的变量在主函数中也都不能使用
C.
形式参数也是局部变量
D.
复合语句中定义的函数只在该复合语句中有效
| 参考答案
答案
A
1分
2-27
下面叙述中正确的是( )。
A.
全局变量在定义它的文件中的任何地方都是有效的
B.
全局变量在程序全部执行过程中一直占用内存单元
C.
替同一文件中的变量不能重名
D.
替使用全局变量有利于程序的模块化和可读性的提高
| 参考答案
答案
B
1分
2-28
若函数的类型和return语句中表达式的类型不一致，则( )。
A.
编译时出错
B.
运行时出现不确定结果
C.
不会出错，且返回值的类型以return语句中表达式的类型为准
D.
不会出错，且返回值的类型以函数的类型为准
| 参考答案
答案
D
1分
2-29
在函数的说明和定义时若没有指出函数的类型，则( )。
A.
系统自动认为函数类型为整型
B.
系统自动认为函数类型为实型
C.
系统自动认为函数类型为字符型
D.
编译时会出错
| 参考答案
答案
A
1分
2-30
C++语言中若不特别声明，则变量的类型被认为是( )。
A.
extern
B.
static
C.
register
D.
auto
| 参考答案
答案
D
1分
2-31
在函数调用语句fun1(fun2 (x，y)，(x，y)，z=x+y); 中，fun1的实际参数的个数是()。
A.
3
B.
7
C.
4
D.
5
| 参考答案
答案
A
1分
2-32
对函数的调用不可以出现在( )。
A.
对一个变量赋初值
B.
调用函数时传递的实际参数
C.
函数的形式参数
D.
引用数组元素[ ]的运算符中
| 参考答案
答案
C
1分
2-33
若用数组名作为函数调用的实参，传递给形参的是( )。
A.
数组的首地址
B.
数组第一个元素的值
C.
数组中全部元素的值
D.
数组元素的个数
| 参考答案
答案
A
1分
2-34
在下面的函数声明中，存在着语法错误的是( ) 。
A.
BC (int a, int) ;
B.
BC (int, int) ;
C.
BC (int, int=5);
D.
BC (int x, int y);
| 参考答案
答案
C
1分
2-35
如果默认参数的函数声明为“ void fun(int a,int b=1,char c='a',float d=3.2);”，
则下面调用写法正确的是（ ）。
A.
fun();
B.
fun(2,3);
C.
fun(2, ,'c',3.14)
D.
fun(int a=1);
| 参考答案
答案
B
1分
2-36
在C++中，关于下列设置缺省参数值的描述中，（）是正确的。
A.
不允许设置缺省参数值；
B.
在指定了缺省值的参数右边，不能出现没有指定缺省值的参数；
C.
只能在函数的定义性声明中指定参数的缺省值；
D.
设置缺省参数值时，必须全部都设置；
| 参考答案
答案
B
1分
2-37
决定C++语言中函数的返回值类型的是（）
A.
return语句中的表达式类型
B.
调用该函数时系统随机产生的类型
C.
调用该函数时的主调用函数类型
D.
在定义该函数时所指定的数据类型
| 参考答案
答案
D
1分
2-38
如有函数定义：void func(int x = 0, int y = 0){ …. }，则下列函数调用中会出现问题的是____。
A.
func(1,2, 3);
B.
func(1,2);
C.
func(1);
D.
func();
| 参考答案
答案
A
1分
2-39
以下选项中，是正确的函数默认形参设置的是。
A.
int fun(int a,int b,int c);
B.
int fun(int a,int b,int c=1);
C.
int fun(int a,int b=1,int c);
D.
int fun(int a=1,int b,int c);
| 参考答案
答案
B
1分
2-40
关于函数的默认参数
若有下面的函数声明
void F(int x = 1, y = 2);
则 ▁▁▁▁▁ 是错误的语句。
A.
F();
B.
F(3);
C.
F(, 5);
D.
F(6, 9);
| 参考答案
答案
C
1分
2-41
在（ ）情况下适宜采用inline定义内联函数。
A.
函数体含有循环语句
B.
函数体含有递归语句
C.
函数代码少、频繁调用
D.
函数代码多、不常调用
| 参考答案
答案
C
1分
2-42
下面说法正确的是（）。
A.
内联函数在运行时是将该函数的目标代码插入每个调用该函数的地方
B.
内联函数在编译时是将该函数的目标代码插入每个调用该函数的地方
C.
类的内联函数必须在类体内定义
D.
类的内联函数必须在类体外通过加关键字inline定义
| 参考答案
答案
B
1分
2-43
当一个函数功能不太复杂，但要求被频繁调用时，选用____。
A.
重载函数
B.
内联函数
C.
递归函数
D.
嵌套函数
| 参考答案
答案
B
1分
程序填空题16 分
5-1
下述程序从控制台读取一个复数b的实部和虚部，然后将这个复数与复数a及实数3.2相加，得到复数c并输出。请参考注释将程序补充完整。
#include <iostream>
#include <iomanip>
using namespace std;
class Complex {
double dReal;
double dImage;
public:
//构造函数(3分)
//operator+操作符函数(4分)
//友元函数声明以帮助operator<<()函数访问Complex类的私有成员(3分)
};
ostream& operator<<(ostream& o, const Complex& c){
o << fixed << setprecision(1) << c.dReal << " + " << c.dImage << "i";
return o;
}
int main() {
double dReal, dImage;
cin >> dReal >> dImage;
Complex a(1,1);
Complex b(dReal,dImage);
Complex c = a + b + 3.2;
cout << c << endl;
return 0;
}
| 参考答案
填空#1
Complex(double real, double image=0){ dReal = real; dImage = image; }
填空#2
Complex operator+(const Complex& r) const{ return Complex(dReal+r.dReal,dImage+r.dImage); }
填空#3
friend ostream& operator<<(ostream& o, const Complex& c);
10分
5-2
#include<iostream>
using namespace std;
class MyInteger {
friend ostream& operator<<(ostream& out, MyInteger myint);
public:
MyInteger() {
m_Num = 0;
}
//前置++
(1分)() {
//先++
(1分)
//再返回
(1分)
}
//后置++
(1分){
//先返回
(1分) //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
m_Num++;
(1分)
}
private:
int m_Num;
};
ostream& operator<<(ostream& out, MyInteger myint) {
out << myint.m_Num;
return out;
}
//前置++ 先++ 再返回
void test01() {
MyInteger myInt;
cout << ++myInt << endl;
cout << myInt << endl;
}
//后置++ 先返回 再++
void test02() {
MyInteger myInt;
cout << myInt++ << endl;
cout << myInt << endl;
}
int main() {
test01();
//test02();
system("pause");
return 0;
}填空#1
MyInteger& operator++
填空#2
m_Num++;
填空#3
return *this;
填空#4
MyInteger operator++(int)
填空#5
MyInteger temp = *this;
填空#6
return temp;
1284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
