面向对象技术与C++(3)答案

《面向对象技术与C++》试卷答案(3)

第一题填充题（10分，每1个空格1分）

1.当使用带参数的流操纵算子时，程序中必须包含(iomanip)头文件。

2.复合对象中的成员对象是在建立复合对象之(前)建立的。

3.运算符new分配的动态内存要用运算符(delete) 回收。如果在一个类的构造函数中使

用new分配动态内存，则回收操作应在类的(析构)函数中完成。

4.struct成员的默认访问模式是(public)，而class成员的默认访问模式是 (private)。

5.关键字(const) 指定了不可修改的对象或变量。关键字(const) 指定一个类的成员不会

修改类中的数据成员。

6.重载赋值运算符operator= 时，应将其声明为类的（成员）函数。

7.C++中的输入/输出是以字节(流) 的形式实现的。

第二题指出下列程序段中的错误，说明错误原因(10分,每1小题5分）1．class Rational { //表示有理数的类声明

public：

void Rational (int,int); //第1个参数为分子，第2个参数为分母

// 其他成员函数的原型说明

private:

void Rational ( ); //默认的数为0，其分子表示为0，分母表示为1

int a = 0 , b = 1;

}

1) void Rational(); 构造函数的访问属性应为public

2) 两个构造函数都不能指定返回类型

3）int a = 0 , b = 1; 不能直接赋初值

4）最后少了一个分号(;)

2．class myClass {

public:

myClass(char a, int b) { v = a ; si = b ; }

void f1(int i = 10) const { v = v + i ; }

static int f2() { return v + si; }

private:

char v;

static int si;

} ;

1) static函数f2()不能访问非static成员v

2) 构造函数中不能对static数据赋值

3) const成员函数f1不能修改数据成员v

4) static数据si需要在类声明的外面进行初始化

第三题选择题 (10分，每1个空格1分)

1．在VC++中，目标文件的扩展名为（B）

[A] .cpp

[B] .obj

[C] .h

[D] .exe

2．通常情况下，模板函数的类型参数个数不能为（A）个。

[A] 0

[B] 1

[C] 2

[D] 2个以上

3．既要禁止修改指针p，又要禁止修改p所指的数据，则p的正确定义是（D）。

[A] const char* p=”xxxx”;

[B] char* const p=”xxxx”;

[C] char const *p=”xxxx”;

[D] const char * const p=”xxxx”;

4．若函数f是类C中的虚函数，类D是类C的公有派生类，则函数f在类D中是（A）。

[A] 总是虚函数

[B] 只有重新声明时才是虚函数

[C] 只有使用virtual关键字重新声明时才是虚函数

[D] 不可能是虚函数

5. 每个类（A）析构函数。

[A] 只能有一个

[B] 只可有私有的

[C] 可以有多个

[D] 只可有缺省的

6. 重载函数调用运算符operator[ ]时，应将其声明为类的（C）函数。

[A] 非成员

[B] 虚

[C] 成员

[D] 多态

7. static成员函数没有（B）。

[A] 返回值

[B] this指针

[C] 指针参数

[D] 返回类型

8. 设T是类名，则声明T a(); 表示a是（A）。

[A] 函数名

[B] 对象名

[C] 函数指针

[D] 引用

8. 设函数f是类A的虚函数，类B是类A的public派生类。

定义B d; A* p=&d; A& r=d; 则采用动态联编的是（B）和（E）。

[A] d.f();

[B] p->f();

[C] p.f();

[D] r->f();

[E] r.f();

第四题简答题(10分)

为什么编译器认为把基类指针转换为派生类指针是危险的？

派生类指针指向基类对象。这种方法是不安全的，因而需要避免。因为通过派生类指针使用派生类自己添加的成员是可以的，但它所指的基类对象中并不存在这种成员。

第五题写出以下程序运行时的输出结果（10分）

#include

using namespace std;

class A {

public:

A() { cout << "initialize A\n"; }

virtual void write() { cout << "class A \n"; }

};

class B: public A {

public:

B() { cout << "initialize B\n"; }

void write() { cout << "class B \n"; }

};

class C: public B {

public:

C() { cout << "initialize C\n"; }

void write() { cout << "class C\n"; }

};

class D: public C {

public: