面向对象程序设计复习题

一、单项选择题。

1引入内联函数的主要目的是
A)缩短程序代码，少占用内存空间
B．既可以保证程序的可读性，又能提高程序的运行效率
C)提高程序的执行速度
D)使程序的结构比较清晰
2重载函数是
A)以函数参数来区分，而不用函数的返回值来区分不同的函数
B．以函数的返回值来区分，而不用函数参数来区分不同的函数
C)参数表完全相同而返回值类型不同的两个或多个同名函数
D)参数表和返回值类型都必须是不同的两个或多个同名函数
3有函数原型 void fun2 (int *), 下面选项中，正确的调用是
A) double x = 2.17。

fun2 (&x)。

C) int a = 15。

fun2 (a*3.14)。

B) int b = 100。

fun2 (& b)。

D) fun2 (256)。

4在C++中,要实现动态联编,必须使用( )调用虚函数。

A) 类名B) 派生类指针 C)对象名D) 基类指针
5 在公有派生情况下，有关派生类对象和基类对象的关系，下列叙述不正确的是
A)派生类的对象可以直接访问基类中的所有成员
B)派生类的对象可以初始化基类的引用
C)派生类的对象可以赋给基类的对象
D) 派生类的对象的地址可以赋给指向基类的指针
6设置虚基类的目的是
A)消除两义性 B) 简化程序
C)提高运行效率 D)减少目标代码
7关于构造函数，以下说法错误的是
A) 构造函数的作用是在对象被创建时使用特定的值构造对象，或者说将对象
初始化为一个特定的状态。

在对象创建时由系统自动调用。

B) 基类的构造函数可以被派生类所继承。

C) 如果程序中未声明，则系统自动产生出一个缺省形式的构造函数。

D) 允许为内联函数、重载函数、带缺省形参值的函数。

8下列关于C++函数的说明中，正确的是
A)内联函数就是定义在另一个函数体内部的函数
B)函数体的最后一条语句必须是return语句
C)标准C++要求在调用一个函数之前，必须先声明其原型
D)编译器会根据函数的返回值类型和参数表来区分函数的不同重载形
式
9 由于常对象不能被更新，因此
A)通过常对象只能调用它的常成员函数
B)通过常对象只能调用静态成员函数
C)常对象的成员都是常成员
D)通过常对象可以调用任何不改变对象值的成员函数
10下列关于虚函数的说明中，正确的是
A)从虚基类继承的函数都是虚函数 B)虚函数不得是静态成员函数
C)只能通过指针或引用调用虚函数 D)抽象类中的成员函数都是虚函数
11 运算符重载是对已有的运算符赋予多重含义，因此
A)可以对基本类型(如int类型)的数据，重新定义“+”运算符的含义
B)可以改变一个已有运算符的优先级和操作数个数
C)只能重载C++中已经有的运算符，不能定义新运算符
D)C++中已经有的所有运算符都可以重载
12模板对类型的参数化提供了很好的支持，因此
A)类模板的主要作用是生成抽象类
B)类模板实例化时，编译器将根据给出的模板实参生成一个类
C)在类模板中的数据成员都具有同样类型
D)类模板中的成员函数都没有返回值
13下列符号中可以用作C++标识符的是
A)_radius B)foo~bar C)else D)3room
14下列语句中，错误的是
A)const int buffer=256。

B)const int temp。

C)const double *point； D)const double *rt =new double(5.5)。

15有如下程序：
int x=3。

do{
x -= 2。

cout<<x。

}while(!(--x))。

执行这个程序的输出结果是
A) 1 B) 3 0 C) l-2 D)死循环
16有如下程序：
#include <iostream>
using namespace std。

int main()
{
int *p。

*p = 9。

cout<<"The value at p:"<<*p。

return 0。

}
编译运行程序将出现的情况是
A)够编译时出现语法错误，不能生成可执行文件
B)运行时一定输出：The value at p: 9
C)运行时一定输出：The value at p: *9
D)运行时有可能出错
17 有如下程序：
#include <iostream>
using namespace std。

int main()
{
void function(double val)。

double val。

function(val)。

cout<<val。

return 0。

}
void function(double val)
{
val = 3。

}
编译运行这个程序将出现的情况是
A)编译出错，无法运行 B)输出：3
C)输出：3.0 D)输出一个不确定的数
18 有如下类定义：
class AA
{
int a。

public:
int getRef() const{return &a。

} //①
int getValue() const{return a。

} //②
void set(int n) const{a=n。

} //③
friend void show(AA aa) const {cout<<aa。

} //④}。

其中的四个函数定义中正确的是
A)① B)② C)③D)④
19有如下程序：
#include <iostream>
using namespace std；
class Base
{
public:
void fun(){cout<<"Base::fun"<<endl。

}。

class Derived:public Base
{
public:
void fun()
{
cout<<"Derived::fun"<<endl。

}
}。

int main()
{
Derived d。

________________。

d.fun()。

return 0。

}
已知其执行后的输出结果为：
Base::fun
Derived::fun
则程序中下划线处应填入的语句是
A)Base.fun()。

B)Base::fun() C)Base->fun() D)fun()。

20下面是重载为非成员函数的运算符函数原型，其中错误的是
A)Fraction operator + (Fraction, Fraction)。

B)Fraction operator - (Fraction)。

C)Fraction& operator = (Fraction&, Fraction)。

D)Fraction& operator += (Fraction&, Fraction)。

21有如下类定义：
class Foo
{
public:
Foo(int v):value(v){} //①
~Foo(){} //②
private:
Foo(){} //③
int value = 0。

//④
}。

其中存在语法错误的行是
A)① B)② C)③ D)④
22 有如下类定义：
class Point
{
int x_, y_。

public:
Point():x_(0), y_(0){}
Point(int x, int y = 0):x_(x),y_(y){} }。

若执行语句Point a(2), b[3]， *c[4]。

则Point类的构造函数被调用的次数是
A)2次 B)3次 C)4次 D)5次23有如下程序：
#include <iostream>
using namespace std。

class A
{
public:
A(){cout<<"A"。

}
~A(){cout<<"~A"。

}
}。

class B:public A
{
A* p。

public:
B(){cout<<"B"。

p = new A()。

}
~B(){cout<<"~B"。

delete p。

} }。

int main()
{
B obj。

return 0。

}
执行这个程序的输出结果是
A)BAA~A~B~AB)ABA~B~A~A
C)BAA~B~A~A D)ABA~A~B~A
24有如下程序：
#include <iostream>
using namespace std。

class Base
{
private:
void funl() const{cout<<"funl"。

}
protected:
void fun2() const{cout<<"fun2"。

}
public:
void fun3() const{cout<<"fun3"。

}
}。

class Derived:protected Base
{
public:
void fun4() const{cout<<"fun4"。

}
}。

int main()
{
Derived obj。

obj.funl()。

//①
obj.fun2()。

//②
obj.fun3()。

//③
obj.fun4()。

//④
return 0。

}
其中有语法错误的语句是
A)①②③④ B)①②③ C)②③④ D)①④25有如下程序：
#include <iostream>
using namespace std。

class Base
{
public:
void funl(){cout<<"Base "<<endl。

}
virtual void fun2(){cout<<"Base"<<endl。

}
}。

class Derived:public Base
{
public:
void funl(){cout<<"Derived"<<endl。

}
void fun2(){cout<<"Derived"<<endl。

}
}。

void f(Base &b){b.funl()。

b.fun2()。

}
int main()
{
Derived obj。

f(obj)。

return 0。

}
执行这个程序的输出结果是
A)Base B)Base C)Derived D)Derived
Base Derived Base Derived
26 有如下类声明：
class SAMPLE
{
int n。

public:
SAMPLE (int i = 0): n(i){}
void setValue(int n0)。

}。

下列关于setValue成员函数的实现中，正确的是
A)SAMPLE::setValue(int n0){n = n0。

}
B)void SAMPLE::setValue(int n0){n = n0。

}
C)void setValue(int n0){n = n0。

}
D)setValue(int n0){n = n0。

}
27．下列函数模板的定义中，合法的是（）。

A．template <typename T> T abs(T x){return x<0?-x:x。

}
B．template class <T> T abs(T x){return x<0?-x:x。

}
C．template T <typename T> abs(T x){return x<0?-x:x。

}
D．template T abs(T x){return x<0?-x:x。

}
28．下列程序的运行结果为（）。

# include <iostream >
class BASE
{ public:
BASE(int i){cout<<"调用基类BASE的构造函数："<<i<<endl。

} }。

class A :public BASE
{public:
A (int a,int b):BASE(a),b1(b)
{cout <<"调用派生类A的构造函数："<<a+b<<endl。

}
private:
BASE b1。

}。

void main()
{
A obj(1,2)。

}
A．调用基类BASE的构造函数：2 B)调用基类BASE的构造函数：1
调用基类BASE的构造函数：1 调用基类BASE的构造函数：2
调用派生类A的构造函数：3 调用派生类A的构造函数：3 C)调用基类BASE的构造函数：2 D)调用基类BASE的构造函数：1
调用派生类A的构造函数：3 调用基类BASE的构造函数：3
29．下列程序的运行结果为（）。

# include<iostream.h>
class T
{ public:
T( int x) { a=x。

b+=x。

}。

static void display( T c)
{cout<<”a=”<<c.a<<’\t’<<”b=”<<c.b<<end l。

} private:
int a。

static int b。

}。

int T::b=5。

void main()
{ T A(3),B(5)。

T::display(A)。

T::display(B)。

}
A) a=3 b=8 B) a=3 b=5
a=5 b=10 a=5 b=5
C．a=3 b=13 D) a=3 b=8
a=5 b=13 a=5 b=13
30.下面程序中对一维坐标点类Point进行运算符重载
#include<iostream>
using namespace std。

class point
{
public:
point （int vaI） {x=val。

}
point＆ operator++（）{x++。

retum*this。

}
point operator++（int） {point old=*this,++（*this）。

retum old。

}
int GetX（） const {retum x。

}
private:
int x。

}。

int main（）
{
point a（10）。

cout<<（++a）.GetX（）。

cout<<a++.GetX（）。

retum（）。

}
编译和运行情况是
A）运行时输出1011 B）运行时输出1111
C）运行时输出1112 D）编译有错
二、填空题。

1 程序中有如下语句
for(int i = 0。

i<5。

i++)cout<<*(p + i)<<","。

能够依次输出int型一维数组DATA的前5个元素。

由此可知，变量p的定义及初始化语句是______________。

2 若下面程序运行时输出结果为
1, A, 10.1
2, B, 3.5
请将程序补充完整。

，
#include
using namespace std。

int main()
{
void test(int, char,double _____________ )。

test(1,'A',10.1)。

test(2,'B')。

return 0。

}
void test(int a, char b, double c)
{
cout<<a<<","<<b<<","<<c<<endl。

}
3有如下类声明：
class MyClass
{
int i。

private: int j。

protected:int k。

public:int m, n。

}。

其中，私有成员的数量为 _____________ 。

4 有如下程序：
#include
using namespace std。

class ONE
{
public:
virtual void f(){cout<<"l"。

}
}。

class TWO:public ONE
{
public:
TWO(){cout<<"2"。

}
}。

class THREE:public TWO
{
public:
virtual void f(){TWO::f()。

cout<<"3"。

} }。

int main()
{
ONE aa, *p。

TWO bb。

THREE cc。

p = &cc。

p->f()。

return 0。

}
执行上面程序的输出是 _____________ 。

5 有如下程序：
#include
using namespace std。

class PARENT
{
public:
PARENT(){cout<<"PARENT"。

}
}。

class SON:public PARENT
{
public:
SON(){cout<<"SON"。

}
}。

int main()
{
SON son。

PARENT *p。

p = &son。

return 0。

}
执行上面程序的输出是_____________ 。

6若以非成员函数形式，为类Bounce重载“！”运算符，其操作结果为一bool型数据，则该运算符重载函数的原型是 _____________ 。

7下面是复数类complex的定义，其中重载的运算符“+”的功能是返回一个新的复数对象，其实部等于两个操作对象实部之和，其虚部等于两个操作对象虚部之和；请补充完整：
class complex
{
double real。

//实部
double imag。

//虚部
public:
complex(double r,double i):real(r),imag(i){}
complex operator+(complex a)
{return complex(_____________ )。

}
}。

8 已知一个函数模板定义为
template T1, typename T2>
T1 FUN(T2 n) {return n * 5.0。

}
若要求以int型数据7为函数实参调用该模板函数，并返回一个double型数据，则该调用应表示为 _____________。

9．设有数组和指针变量定义为：int a[2][3]={{1，2}，{3，4，5}}，*p=&a[0][2]；则表达式*(p+1)的值为：。

10．有字符数组和字符指针定义：char s1[]=”string”,char s2[]=”char”；char *const ps=s1；则使用指针ps进行操作时，可以改变ps，但不能改变ps。

11.设Cat是已定义的类，整型变量a是Cat类的公有成员变量，p是Cat类的对象指针，且已指向Cat类的对象c，则用指针p给整型成员变量a赋值5的语句为：。

12．在C++语言中，运算符可以重载，运算符重载实质上就是函数的重载，运算符重载实现的多态性属于：。

13．在C++语言中，运算符可以重载，运算符重载实质上就是函数的重载，设后置运算符“++”在类A的定义中被重载为成员函数，则对A类对象a作运算a++，与该运算表达式等价的函数调用形式为：。

14.当保护继承时，基类的成员在派生类中成为保护成员，不能通过派生类的对象来直接访问该成员。

15.在类中，____________成员为类的所有对象所共享。

16. 如果使用数组名作为函数参数，形实结合时，传递的是__________。

17.有如下定义：
class MA
{
int value。

public:
MA（int n=0）:valut（n）{}
}。

MA*ta,tb。

其中MA类的对象名标识符是_____________。

18.若将一个二元运算符重载为类的成员函数，其形参个数应该是________ 个。

19.有如下程序：
#include<iostream>
using namespace std。

class DA{
int k。

public:
DA（int x=1）: k （x）{}
～DA（）{cout<<k 。

}
}。

int main（）{
DA d[]={DA（3）,DA（3）,DA（3）}。

DA* p=new DA[2]。

delete[]p。

return0。

}
这个程序的输出结果是 ____________ 。

20.C++语言中的多态性分为编译时的多态性和__________ 时的多态性。

三、简答题。

1. 什么叫做友元函数，什么叫做友元类？
2．什么叫做多态性，面向对象的多态性可以分为哪四类？
3．什么叫做作用域？C++中有哪几种类型的作用域？
4．对比简述C语言中函数内静态局部变量与C++中类的静态成员变量的特点。

5．简述用虚函数实现动态多态性的三个关键之处。

6．什么是内联函数，它有哪些特点？
7．列出拷贝构造函数被调用的三种情况。

8．比较类的三种继承方式public、protected、private之间的差别。

9．什么是虚基类？有何作用？
10．什么是编译时的多态？具体包括哪些类型？
11．函数模板与函数重载有哪些区别？
12．构造函数与析构函数有什么作用？
四、综合编程题。

1．函数编程：
定义一函数模板swap，它能实现x、y值的交换，在main函数中用任
意两个整数、两个浮点数分别使用这个函数模板。

2．函数编程：
定义一函数void ContraryStr(char * str)，它能实现字符串的逆序
输出，在main函数中用任意字符串测试该函数。

3．类编程：定义一个表示工人的类Worker，有两个普通数据成员工龄age 和工资pay，有一个静态成员人数sum；定义一个有二个参数的构造函
数，给age和pay赋值，令sum++；给sum初始化为0，定义一个静态
成员函数getsum，用于获得sum的值；在main函数中以不同的方式定
义二个工人对象，分别用二个对象和类名3种方式调用getsum函数并
输出相应人数。

4．派生类和虚函数编程：
（1）定义一个抽象类Shape，并且提供二个纯虚函数：计算并返回面积函数reArea及计算并返回体积函数reV olume。

（2）由Shape类派生Cube（正方体）类,它包括私有数据成员length （边长）,还包含构造函数和两个纯虚函数的实现。

（3）由Shape类派生Ball（球形）类,它包括私有数据成员radius（半径）, 也包含构造函数和两个纯虚函数的实现。

(注：球表面积公式＝4πR2,球体积公式＝(4π/3)R3 )。

（4）在main函数中创建矩形类、球类对象存入一个shape类指针数组中，通过for循环将数组中各类图形的面积及体积输出。

(30
分)
5．运算符重载编程：
（1）设计一个简单分数类Fenshu，其包含两个整数的类数据成员分子fenzi、分母fenmu，定义并实现一个有两个整数作参数的构
造函数，并定义一个普通成员函数show()，它能以
“fenzi/fenmu”格式输出分数；
（2）用成员函数方式重载+运算符，用友元函数方式重载-运算符，实现分数类的+和-运算。

（3）在main函数中使用Fenshu类和二个重载运算符进行+和-运算，并调用show()函数进行输出。