面向对象程序设计复习题

《面向对象程序设计》复习题

一、单项选择题

1.（A）是面向对象系统包含的要素。

A、类

B、多态

C、友元

D、重载

2.下列对常量的定义中，错误的是（ C ）。

A、MyClass const obj(3,4);

B、char * const p="hello";

C、int &ref=2;

D、void show() const;

3.若有如下函数声明：void Fun(int x);，则下列（D ）能与该函数形成重载。

A、void Fun(int y);

B、void Fun(int x,int y='1');

C、int Fun(int x);

D、void Fun(int) const;

4.下列对构造函数和析构函数的描述中，错误的是（ B ）。

A、构造函数可以重载

B、析构函数名与类名相同

C、构造函数中可以设置参数的缺省值

D、类中只有一个析构函数

5.下列对友元的描述中，错误的是（ C ）。

A、友元破坏了类的封装性

B、友元提高了程序的运行效率

C、友元可以在类外声明和定义

D、友元能够访问类中的私有成员

6.下列对继承的描述中，正确的是（ A ）。

A、公有派生类对象能够访问基类的公有成员

B、派生类只继承了基类的公有成员和保护成员

C、派生类对象不能访问基类的保护成员

D、派生类不改变基类成员的访问权限

7.程序中，编译时出错的语句是（D ）。

class Base{ };

class Derived : public Base { };

Derived objD1;

Base objB=objD1; 数据成员 C.构造函数 D.静态成员函数

答案：C

分析：当一个对象定义时，C++编译系统自动调用构造函数建立该对象并进行初始化；当一个对象的生命周期结束时，C++编译系统自动调用析构函数注销该对象并进行善后工作；

?

?

28：下列表达方式正确的是（）。

A．class P{ B． class P{

public： public：

int x=15； int x；

void show(){cout<

}； }

C． class P{ D. class P{

int f; public：

}； int a；

f=25； void Seta (int x) {a=x;}};

答案：D

分析：在类体内不可对数据成员进行初始化；类定义结束时需用分号；只有类中的成员函数才能存取类中的私有数据。

?

29：拷贝构造函数具有的下列特点中，（）是错误的。

A．? 如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的

B．? 拷贝构造函数至少有一个参数，并且是该类对象的引用

C．? 拷贝构造函数是一种成员函数

D．拷贝构造函数的名字不能用类名

答案：D

分析：如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的；拷贝构造函数至少有一个参数，并且是该类对象的引用；拷贝构造函数的名字与类同名，并且不被指定返回类型；拷贝构造函数是一种成员函数。

?

30：关于静态成员的描述中，（）是错误的。

A．? 静态成员可分为静态数据成员和静态成员函数

B．? 静态数据成员定义后必须在类体内进行初始化

C．? 静态数据成员初始化不能在构造函数中完成

D．? 静态成员函数中不能直接引用非静态成员

答案：B

分析：静态成员可分为静态数据成员和静态成员函数；静态数据成员被定义后，必须对它进行初始化，初始化在类体外进行，一般放在该类的实现部分最合适，也可以放在其他位置，例如，放在主函数前面等；静态数据成员初始化与该类的构造函数和析构函数无关；在静态成员函数的实现中，可以直接引用静态成员，但不能直接引用非静态成员。

?

31：关于友元的描述中，（）是错误的。

A．? 友元函数是成员函数，它被说明在类体内

B．?? 友元函数可直接访问类中的私有成员

C．?? 友元函数破坏封装性，使用时尽量少用

D．?? 友元类中的所有成员函数都是友元函数

答案：A

分析：友元函数是非成员函数，在类体内说明了，在类体外定义，定义和调用等同于一般的普通函数；由于它可以直接访问类的私有成员，因此破坏了类的封装性和隐藏性，尽量少用。

?

二、填空题

1.下列运算符既可以作为类的成员函数重载，也可以作为类的友元函数重载，请在表格中的空

1.答案: (1) +(b) (2) operator +(a,b)

(3) ++() (4) operator –(a)

2.下列程序执行后的输出结果是12,21,22，请将下列程序补充完整。

#include <>

void fun1( (1) , int b) { int c; c=a; a=b; b=c; }

void fun2( (2) , int *b) { int c; c=*a; (3) ; *b=c; }

void fun3( (4) , int b) { int c; c=a; (5) ; b=c; }

void main(){

int x,y;

x=1; y=2; fun1(x,y); cout<

x=1; y=2; fun2(&x,&y); cout<

x=1; y=2; fun3(x,y); cout<

}

2.答案: (1) int a (2) int *a (3) *a=*b

(4) int &a (5) a=b

3.下列程序执行后的输出结果是B0 D00 B1 D23 ~D ~B ~D ~B，请将下列程序补充完整。

class Base {

public:

Base(int i=0) {x = i; cout<<'B'<

~Base() { cout<<"~B"<

private:

int x;

};

class Derived : public Base {

int y, z;

public:

__________________(1)________________________员名”的形式访问的对象成员仅限于被声明为 (1) 的成员；若要访问其他成员变量，需要通过 (2) 函数或 (3) 函数。答案：(1) public (2) 成员 (3)友元

分析：类体内的数据成员可声明为公有的、私有的和保护的，公有的数据成员可利用“对象名.成员名”形式来进行访问；私有的数据成员能被类中的成员函数或友元函数所调用；保护的数据成员可以在类体中使用，也可以在派生类中使用，但不能在其他类外通过对象使用。

三、写程序结果题

1.#include <>

class Test {

public:

Test (double m,double n,double d):p(d) { x=m; y=n; }

void Show();

void Show() const;

private:

double x, y;

const double p;

};

void Test::Show() {

cout<

cout<<"p="<

}

void Test::Show() const {

cout<

cout<<"p="<

}

void main() {

Test a,,;

();

const Test b,,;

();

}

答案：

p=

const

p= const

2.#include <>

class A{

public:

A(int i){ cout<<"Constructor"<

A(A& r){cout<<"Copy constructor"<

~A(){cout<<"Destructor"<

A& operator =(A& r);

void output() {cout<<*p<

private:

int *p;

};

A& A::operator =(A& r) {

cout<<"Assignment"<

if(this==&r) return *this;

delete p;

p=new int;

return *this;

};

void main(){

A a(5);

A b=a;

A c(6);

c=a;

();

};

答案：Constructor

Copy constructor

Constructor

Assignment

5

Destructor

Destructor

Destructor

3.#include <>

class Base1{

public:

Base1(int x) { cout<<"Base1's con. "<

~Base1() { cout<<"Base1's des. "<

};

class Base2{

public:

Base2(int x) { cout<<"Base2's con. "<

~Base2() { cout<<"Base2's des. "<

};

class Derived : public Base2,public Base1{

public:

Derived(int x,int y):Base1(y),Base2(x) { cout<<"Derived's con."<

~Derived() { cout<<"Derived's des."<

};

void main(){

Derived obj(1,2);

}

答案：Base2's con. 1

Base1's con. 2

Derived's con.

Derived's des.

Base1's des.

Base2's des.

4．# include <>

class A {

int a,b;

public :

A() {

a=b=0;

cout<<"Default Constructing Object"<<' '<

}

A(int aa,int bb) {

a=aa; b=bb;

cout<<" Constructing Object"<<' '<

}

~A() {cout<<"Destructing Object"<<' '<

};

void main()

{

A x,y(2,3),z(4,5);

}

答案：Default Constructing Object 0 0

Constructing Object 2 3

Constructing Object 4 5

Destructing Object 4 5

Destructing Object 2 3

Destructing Object 0 0

5． # include <>

template

class FF {

TT a1,a2,a3;

public :

FF(TT b1,TT b2,TT b3) {

a1=b1; a2=b2; a3=b3;

}

TT Sum() { return a1+a2+a3; }

};

void main()

{

FF x(2,3,4),y(5,7,9);

cout <<()<<' '<<()<

}

答案：9 21

6：分析找出以下程序中的错误，说明错误原因，给出修改方案使之能正确运行。

#include<>

class one

{

int a1,a2;

public:

one(int x1=0, x2=0);

};

void main()

{

one data(2,3);

cout<<<

cout<<<

}

分析：出错原因：构造函数参数表语法错；构造函数没有函数体；类的对象不能直接访问类的私有成员。

改正后的程序如下：

#include<>

class one

{ int a1, a2;

public:

one(int x1=0, int x2=0) {a1=x1;a2=x2;}

int geta1() { return a1; }

int geta2() { return a2; }

};

void main()

{one data(2,3);

cout<<()<

cout<<()<

}

7：分析以下程序的错误原因，给出修改方案使之能正确运行。

#include <>

class Amplifier{

float invol,outvol;

public:

Amplifier(float vin,float vout)

{invol=vin;outvol=vout;}

float gain();

};

Amplifier::float gain() { return outvol/invol; }

void main()

{ Amplifier amp,;

cout<<"\n\nThe gain is =>"<

}

分析：成员函数在类体外定义格式是：函数返回类型类名：：成员函数名（参数表）；成员函数调用格式是：对象名.成员函数名（参数表）。

改正后的程序如下：

#include <>

class Amplifier

{ float invol,outvol;

public:

Amplifier(float vin,float vout) {invol=vin;outvol=vout;}

float gain();

};

float Amplifier::gain() { return outvol/invol; }

void main()

{ Amplifier amp,;

cout<<"\n\nThe gain is =>"<<()<

}

?

8：下列程序的运行结果是。

#include <>

class point

{ int x,y;

public:

point(int a,int b)

{x=a;y=b;

cout<<"calling the constructor function."<

}

point(point &p);

friend point move(point q);

~point(){cout<<"calling the destructor function.\n";}

int getx() {return x;}

int gety() {return y;}

};

point::point(point &p)

{x=; y=;

cout<<"calling the copy_initialization constructor function.\n";

}

point move(point q)

{cout<<"OK!\n";

int i,j;

i=+10;

j=+20;

point r(i,j);

return r;

}

void main()

{ point m(15,40),p(0,0);

point n(m);

p=move(n);

cout<<"p="<<()<<","<<()<

}

答案：

calling the constructor function.

calling the constructor function.

calling the copy_initialization constructor function.

calling the copy_initialization constructor function.

OK！

calling the constructor function.

calling the copy_initialization constructor function.

calling the destructor function.

calling the destructor function.

calling the destructor function.

P=25,60

calling the destructor function.

calling the destructor function.

calling the destructor function.

说明：

（1）构造函数执行三次，分别初始化主函数中的对象m，p和move函数中的对象r。

（2）拷贝构造函数共执行了三次。第一次，初始化对象n；第二次在调用函数move()时，实参n给形参q进行初始化；第三次是执行函数move的return r；语句时，系统用r初始化一个临时对象时使用了拷贝构造函数。

（3）析构函数执行了六次。在退出函数move时释放对象r和q共调用二次；返回主函数后，临时对象赋值给对象p后，释放临时对象又调用一次析构函数；最后退出整个程序时释放对象m，n和p调用三次。

四、编程题

1. 根据下面类中Count函数成员的原型和注释写出它的类外定义。

class AA {

int* a;

int n;

int MS;

public:

void InitAA(int aa[], int nn, int ms) {

if(nn>ms) {cout<<"Error!"<

MS=ms;

n=nn;

a=new int[MS];

for(int i=0; i

}

int Count(int x); 根据下面类中Search函数成员的原型和注释写出它的类外定义。

class AA {

int* a;

int n;

int MS;

public:

void InitAA(int aa[], int nn, int ms) {

if(nn>ms) {cout<<"Error!"<

MS=ms;

n=nn;

a=new int[MS];

for(int i=0; i

}

int Search(int x); 根据下面类中MaxMin 函数成员的原型和注释写出它的类外定义。class AA {

int* a;

int n;

int MS;

public:

void InitAA(int aa[], int nn, int ms) {

if(nn>ms) {cout<<"Error!"<

MS=ms;

n=nn;

a=new int[MS];

for(int i=0; i

}

int MaxMin(int& x, int& y); 根据下面类中Compare 函数成员的原型和注释写出它的类外定义。

class AA {

int* a;

int n;

int MS;

public:

void InitAA(int aa[], int nn, int ms) {

if(nn>ms) {cout<<"Error!"<

MS=ms;

n=nn;

a=new int[MS];

for(int i=0; i

}

int Compare(AA b); 根据下面类中CompareBig 函数成员的原型和注释写出它的类外定义。class AA {

int* a;

int n;

int MS;

public:

void InitAA(int aa[], int nn, int ms) {

if(nn>ms) {cout<<"Error!"<

MS=ms;

n=nn;

a=new int[MS];

for(int i=0; i

}

int CompareBig(AA b); //比较*this与b的大小，从前向后按两数组

//中的对应元素比较，若*this中元素值大则返回1，若b中

//元素值大则返回-1，若相等则继续比较下一个元素，直到

//一个数组中无元素比较，此时若两者的n值相同则返回0，

//否则若*this中的n值大则返回1，若b中的n值大则返回-1。};

答案：

int AA::CompareBig(AA b)

{

int k;

if(n> k=; else k=n;

for(int i=0; i

if(a[i]>[i]) return 1;

else if(a[i]<[i]) return -1;

if(k==n && k== return 0;

else if(k

else return -1;

}