首页 > 编程语言> 文章详细

C++课后习题第五章

2022-01-11 23:03:20 阅读：217 来源： 互联网

标签：课后 int void C++ 答案基类习题 public 函数

第5章多态性

一、单选题（共17题，100分）

1下列有关继承和派生的叙述中，正确的是( )

A. 派生类不能访问基类的保护成员

B. 作为虚基类的类不能被实例化

C.派生类应当向基类的构造函数传递参数

D.虚函数必须在派生类中重新实现

我的答案: C正确答案: C

答案解析：答案解析解析派生类可以访问基类的保护成员，而不能访问基类的私有成员。作为虚基类的类可以被实例化。虚函数如果没有派生类中重新实现，那么仍然使用基类的成员函数

2有如下类定义： class Shape{ public: 【1】 //纯虚函数Draw的声明 }; 程序中【1】处缺失的纯虚函数Draw的声明是( )。

A.void Draw()=0;

B.virtual void Draw()=0;

C.virtual void Draw(){ }

D. virtual void Draw(int=0);

我的答案: B正确答案: B

答案解析：在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的派生类去做。这就是纯虚函数的作用。一般形式如下：

class <类名>

{

virtual <类型> <函数名>(<参数表>)=0;

…

};

所以B选项正确。

3有如下程序：

#include <iostream>

using namespace std;

class Book {

public:

Book(char* t=" ") { strcpy(title,t); }

【1】

private:

char title[40];

};

class Novel : public Book {

public:

Novel(char* t=" "): Book(t) { }

char* Category()const { return "文学"; }

};

int main() {

Book *pb;

pb=new Novel();

cout<<pb->Category();

delete pb;

return 0;

}

若程序运行时输出结果是"文学"，则程序中【1】处缺失的语句是( )。

A.char* Category();

B.char* Category()const;

C.virtual char* Category()const;

D. virtual char* Category()const=0;

我的答案: D正确答案: D

答案解析：本题考查纯虚函数和抽象类，纯虚函数是在声明虚函数时被"初始化"为0的函数，包含纯虚函数的类为抽象类，抽象类是不能被实例化的，但是可以定义指向抽象类数据的指针变量，当派生类成为具体类后，就可以用这种指针指向派生类的对象，然后通过该指针调用虚函数，实现多态性的操作。所以本题答案为D。

4.有如下程序：

#include<iostream>

using namespace std;

class GA {

public:

virtual int f() { return 1; }

};

class GB: public GA {

public:

virtual int f() { return 2; }

};

void show(GA g) { cout<<g.f(); }

void display(GA &g) { cout<<g.f(); }

int main()

{

GA a; show(a); display(a);

GB b; show(b); display(b);

return 0;

}

执行这个程序的输出结果是( )。

A.1111

B.1211

C.1112

D.1212

我的答案: C正确答案: C

5.8分

答案解析：本题主要考查虚函数。虚函数指在某基类中声明为virtual并在一个或多个派生类中被重新定义的成员函数，本题中定义类GA的对象a，执行show(a)、display(a)，输出11，定义了类GB的对象b，执行show(b)，仍然输出1，display(b)执行会调用派生类的f函数，因为f函数为虚函数，输出2，所以本题答案为C。

5有如下程序：

#include<iostream>

#include<string>

using namespace std;

class Instrument{

public:

Instrument(string t="乐器",string n="无名"):type(t),name(n) { }

virtual string GetType() const { return "乐器"; }

virtual string GetName() const { return "无名"; }

protected:

string type,name;

};

class Piano:public Instrument{

public:

Piano(string n,string t="钢琴"):Instrument(t,n) { }

string GetType() const { return "钢琴"; }

string GetName() const { return name; }

};

int main(){

Instrument *pi=new Piano("星空");

cout<<pi->GetType()<<'-'<<pi->GetName();

delete pi;

return 0;

}

运行时的输出结果是( )。

A.钢琴-星空

B. 钢琴-无名

C.乐器-星空

D.乐器-无名

我的答案: A正确答案: A

5.8分

答案解析：本题考查虚函数的运用，本题中基类Instrument，派生类Piano，其中虚函数为GetType，当定义Instrument *pi=new Piano("星空")时，调用派生类的GetType函数，得到type为钢琴，name为星空，所以输出钢琴-星空。选项A正确。

6有如下程序：

#include <iostream>

using namespace std;

int i=1;

class Fun {

public:

static int i;

int value(){ return i-1;}

int value()const{ return i+1;}

};

int Fun::i=2;

int main(){

int i=3;

Fun fun1;

const Fun fun2;

【1】

return 0;

}

若程序的输出结果是：

123

则程序中【1】处遗漏的语句是( )。

A. cout<<fun1.value()<<Fun::i<<fun2.value();

B. cout<<Fun::i<<fun1.value()<<fun2.value();

C. cout<<fun1.value()<<fun2.value()<<Fun::i;

D. cout<<fun2.value()<<Fun::i<<fun1.value();

我的答案: A正确答案: A

答案解析：本题考查构造函数、常成员函数和静态数据成员。外部同名的变量赋值，不能改变类的静态变量值，所以Fun对象里的i值为2，所以本题答案为A。

7有如下头文件：

int f1();

static int f2();

class MA {

public:

int f3();

static int f4();

};

在所描述的函数中，具有隐含的this指针的是( )。

A.f1

B.f2

C.f3

D. f4

我的答案: C正确答案: C

答案解析：只有类的非静态成员函数才隐含this指针，其作用域是类内部，当类的非静态成员函数中访问类的非静态成员时，编译器会自动将对象本身的地址作为一个隐含参数传递给函数，而不必一定写上this。所以本题答案为C。

8有如下程序：

#include <iostream>

using namespace std;

class MyClass {

public:

MyClass() { ++count; }

~MyClass() { --count; }

static int getCount() { return count; }

private:

static int count;

};

int MyClass::count=0;

int main()

{

MyClass obj;

cout<<obj.getCount();

MyClass *ptr=new MyClass;

cout<<MyClass::getCount();

delete ptr;

cout<<MyClass::getCount();

return 0;

}

执行这个程序的输出结果是( )。

A.121

B.232

C.221

D.122

我的答案: A正确答案: A

答案解析：本题考查静态数据成员。静态数据成员在内存中只占一份空间，静态数据成员属于类，即使不定义对象，也会给静态数据成员分配空间，可以被引用。本题中先是定义了一个对象obj，执行构造函数使得静态数据成员count变为了1，然后又定义了指针对象，执行构造函数后，count变为了2，释放指针后，执行析构函数，使得count变为了1。所以本题答案为A。

9有如下类定义：

class Test

{

public:

Test() { a = 0; c = 0; } // ①

int f(int a) const { this->a = a; } // ②

static int g() { return a; } // ③

void h(int b) { Test::b = b; }; // ④

private:

int a;

static int b;

const int c;

};

int Test::b = 0;

在标注号码的行中，能被正确编译的是( )。

A.①

B.②

C.③

D.④

我的答案: D正确答案: D

答案解析：只能通过构造函数的参数初始化列表对常数据成员进行初始化，本题中常数据成员为c。①通过默认构造函数初始化c，所以不正确。常成员函数只能引用本类中数据成员，而不能修改它，所以②不正确。静态成员函数由于没有this指针，所以不能访问本类中的非静态成员，所以③错误。

10有如下程序：

#include<iostream>

#include<string>

using namespace std;

class Animal{

public:

virtual string GetType() const { return "Animal"; }

virtual string GetVoice() const { return "Voice"; }

};

class Dog:public Animal{

public:

string GetType() const { return "Dog"; }

string GetVoice() const { return "Woof"; }

};

class Cat:public Animal{

public:

string GetType() const { return "Cat"; }

string GetVoice() const { return "Miaow"; }

};

void Type(Animal& a) { cout<<a.GetType(); }

void Speak(Animal a) { cout<<a.GetVoice(); }

int main() {

Dog d; Type(d); cout<<" speak "; Speak(d); cout<<" - ";

Cat c; Type(c); cout<<" speak "; Speak(c); cout<<endl;

return 0;

}

运行时的输出结果是( )。

A.Dog speak Voice - Cat speak Voice

B.Dog speak Woof - Cat speak Miaow

C.Animal speak Voice - Animal speak Voice

D. Animal speak Woof - Animal speak Miaow

我的答案: A正确答案: A

答案解析：本题考查虚函数的运用，本题中定义Dog d; Type(d)时，执行类Dog的GetType函数，输出Dog，然后输出speak，然后执行基类的Speak函数输出Voice，最后输出-，同理cat输出类似，所以结果为A选项正确。

11有如下程序：

#include <iostream>

using namespace std;

class B {

public:

virtual void show() { cout<<"B"; }

};

class D: public B {

public:

void show() { cout<<"D"; }

};

void fun1(B *ptr) { ptr->show(); }

void fun2(B &ref) { ref.show(); }

void fun3(B b) { b.show(); }

int main()

{

B b,*p=new D;

D d;

fun1(p);

fun2(b);

fun3(d);

delete p;

return 0;

}

执行这个程序的输出结果是( )。

A.BBB

B.BBD

C.DBB

D.DBD

我的答案: C正确答案: C

答案解析：本题考查虚函数。虚函数指在基类中声明为virtual并在一个或多个派生类中被重新定义的成员函数。本题中定义类B的对象 b、对象指针*p=new D以及类D的对象d；执行fun1会调用派生类的show函数，因为show函数为虚函数，而调用fun2、fun3仍然为基类的show函数，所以本题答案为C。

12有如下程序：

#include <iostream>

using namespace std;

class A {

public:

virtual void func1() { cout<<"A1"; }

void func2() { cout<<"A2"; }

};

class B:public A {

public:

void func1() { cout<<"B1"; }

void func2() { cout<<"B2"; }

};

int main() {

A *p=new B;

p->func1();

p->func2();

delete p;

return 0;

}

执行这个程序的输出结果是( )。

A.B1B2

B.A1A2

C.B1A2

D.A1B2

我的答案: C正确答案: C

答案解析：本题考查虚函数。虚函数指在基类中声明为virtual并在一个或多个派生类中被重新定义的成员函数。题中定义了一个派生类对象B，并使用类A的对象指针指向B，由于基类A中的func1为虚函数，所以会执行派生类的func1，输出B1，而基类中的func2不是虚函数，所以p->func2( )会执行基类的func2，输出A2。故答案为C。

有如下程序：

#include <iostream>

using namespace std;

class Instrument {

public:

virtual void Display()=0;

};

class Piano : public Instrument {

public:

void Display() { /*函数体略*/ }

};

int main() {

Instrument s;

Instrument *p=0;

//… ;

return 0;

}

下列叙述中正确的是( )。

A.语句"Insturment *p=0;"编译时出错

B.语句"Instrument s;"编译时出错

C.类Piano中的Display函数不是虚函数

D. 类Instrument是一个虚基类

我的答案: B正确答案: B

答案解析：本题考查纯虚函数和抽象类，纯虚函数是在声明虚函数时被"初始化"为0的函数，包含纯虚函数的类为抽象类，抽象类不能被实例化，所以语句"Instrument s;"在编译时出错。

14有如下程序：

#include <iostream>

using namespace std;

class Base

{

public:

void fun1() { cout<<"Base\n"; }

virtual void fun2() { cout<<"Base\n"; }

};

class Derived : public Base {

public:

void fun1() { cout<<"Derived\n"; }

void fun2() { cout<<"Derived\n"; }

};

void f(Base& b) { b.fun1(); b.fun2(); }

int main()

{

Derived obj;

f(obj);

return 0;

}

执行这个程序的输出结果是( )。

A. Base Base

B.Base Derived

C. Derived Base

D.Derived Derived

我的答案: B正确答案: B

答案解析：本题考查虚函数。虚函数指在基类中声明为virtual并在一个或多个派生类中被重新定义的成员函数。本题中定义了一个派生类对象obj，执行f函数后，将派生类对象obj转化为基类对象，由于fun1不是虚函数，所以调用基类的fun1；而fun2是虚函数，所以调用派生类的fun2，所以本题答案为B。

15有如下程序：

#include <iostream>

using namespace std;

class Base {

public:

void output() { cout<<1; }

virtual void Print() { cout<<′B′; }

};

class Derived : public Base {

public:

void output() { cout<<2; }

void Print() { cout<<′D′; }

};

int main()

{

Base *ptr=new Derived;

ptr->output();

ptr->Print();

delete ptr;

return 0;

}

执行这个程序的输出结果是( )。

A. 1B

B.1D

C.2B

D.2D

我的答案: B正确答案: B

答案解析：本题考查虚函数。虚函数指在基类中声明为virtual并在一个或多个派生类中被重新定义的成员函数。本题中定义了一个指向派生类对象的基类指针ptr，执行ptr->output后，会执行基类的output函数，输出1，由于Print是虚函数，所以ptr->Print（）会执行派生类的Print，即输出D，所以本题答案为B。

16下列选项中，与实现运行时多态性无关的是( )。

A.重载函数

B.虚函数

C.引用

D.指针

我的答案: A正确答案: A

答案解析：运行时多态与虚函数有关。派生类的对象可以认为是基类的对象，但基类的对象不是其派生类的对象。因此，C++允许一个基类对象的指针指向其派生类对象，但不允许一个派生类对象指向其基类对象。在调用虚函数的过程中指针和引用会起到一定的作用。

17下列关于虚函数的叙述中，正确的是( )。

A.虚函数不得是静态成员函数

B.从虚基类继承的函数都是虚函数

C.只能通过指针或引用调用虚函数

D.抽象类中的成员函数都是虚函数

我的答案: A正确答案: A

答案解析：本题考查虚函数，在某基类中声明为 virtual 并在一个或多个派生类中被重新定义的成员函数成为虚函数，虚函数不得是静态成员函数，但可以是友元函数

所有习题完整版PDFhttps://download.csdn.net/download/lornaleo/75413292

标签：课后,int,void,C++,答案,基类,习题,public,函数
来源： https://blog.csdn.net/lornaleo/article/details/122437863

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

C++课后习题第五章