C++面向对象程序设计第8章 继承与派生习题解答

第8章习题
一、概念题
1．解答要点如下。

⑴采用public公有派生，基类成员的访问权限在派生类中保持不变，即基类所有的公有或保护成员在派生类中仍为公有或保护成员。

public派生最常用，可以在派生类的成员函数中访问基类的非私有成员，可通过派生类的对象直接访问基类的公有成员。

⑵采用private私有派生，基类所有的公有和保护成员在派生类中都成为私有成员，只允许在派生类的成员函数中访问基类的非私有成员。

private派生很少使用。

⑶采用protected保护派生，基类所有的公有和保护成员在派生类中都成为保护成员，只允许在派生类的成员函数和该派生类的派生类的成员函数中访问基类的非私有成员。

2．解答要点如下。

派生类构造函数的执行次序：首先，调用基类构造函数，调用顺序按照它们被继承时声明的基类名顺序执行；其次，调用内嵌对象构造函数，调用次序为各个对象在派生类内声明的顺序；最后，执行派生类构造函数体中的内容。

派生类析构函数执行过程与构造函数执行过程相反。

即当派生类对象的生存期结束时，首先调用派生类的析构函数，然后调用内嵌对象的析构函数，再调用基类的析构函数。

3．解答要点如下。

在多重继承中，如果多条继承路径上有一个公共的基类，则在这些路径的汇合点上的派生类会产生来自不同路径的公共基类的多个拷贝，如果用virtual把公共基类定义成虚基类，则只会保留公共基类的一个拷贝。

引进虚基类的目的是为了解决二义性问题，使得公共基类在它的派生类对象中只产生一个基类子对象。

二、填空题
1．派生类基类
2．public、protected、private
3．virtual
4．基类派生类自身
5．成员函数
三、编程题
1．
#include<iostream.h>
#include<string.h>
#include<iomanip.h>
class base //定义一个基类
{protected:
char name[20]; //姓名
char sex[3]; //性别
int age; //年龄
…
};
class teacher:public base //基类派生出教师类
{ int sno; //工号
char zc[20]; //职称
double wages; //工资
…
};
class student :public base //基类派生出学生类{ int sno; //学号
char bj[10]; //班级
char zy[10]; //专业
double score; //入学成绩…
};
2．
class Shape{
public:
virtual float area()=0;
};
float total(Shape *s[],int n)
{
float sum=0.0;
for(int i=0;i<n;i++)
sum+=s[i]->area();
return sum;
}
class Triangle:public Shape
{
public:
Triangle(double h,double w){H=h;W=w;}
double area() const{return H*W*0.5;}
private:
double H,W;
};
class Rectangle:public Shape
{
public:
Rectangle(double h,double w){H=h;W=w;}
double area()const{return H*W;}
private:
double H,W;
};
3．
#include<iostream.h>
class Vehicle
{
protected:
int wheels;
double weight;
public:
void initialize(int whls, double wght);
int get_wheels() { return wheels; }
double get_weight() { return weight; }
double wheel_loading() { return weight/wheels; }
};
class Car:public Vehicle
{
private:
int passenger_load;
public:
void initialize(int whls, double wght, int people =4);
int passengers() { return passenger_load; }
};
class Truck: public Vehicle
{
private:
int passenger_load;
double payload;
public:
void init_truck(int number =2, double max_load =24000.0);
double efficiency();
int passengers() { return passenger_load; }
};
void Vehicle::initialize(int whls, double wght)
{
wheels=whls;
weight=wght;
}
void Car::initialize(int whls, double wght, int people)
{
wheels=whls;
weight=wght;
passenger_load=people;
}
void Truck::init_truck(int number, double max_load)
{
passenger_load=number;
payload=max_load;
}
double Truck::efficiency()
{
return payload/(payload+weight);
}
void main()
{
Vehicle bicycle;
bicycle.initialize(2,25);
cout<<"the bicycle has "<<bicycle.get_wheels()<<" wheels.\n";
cout<<"the bicycle weighs "<<bicycle.get_weight()<<" pounds.\n";
cout<<"the bicycle's wheel loading is "<<bicycle.wheel_loading()<<" pounds per tire.\n\n";
Car audi;
audi.initialize(4,3500.0,5);
cout<<"the audi has "<<audi.get_wheels()<<" wheels.\n";
cout<<"the audi weighs "<<audi.get_weight()<<" pounds.\n";
cout<<"the audi's wheel loading is "<<audi.wheel_loading()<<" pounds per tire.\n\n";
Truck jief;
jief.initialize(18,12500.0);
jief.init_truck(2,33675.0);
cout<<"the jief has "<<jief.get_wheels()<<" wheels.\n";
cout<<"the jief weighs "<<jief.get_weight()<<" pounds.\n";
cout<<"the jief's efficiency is "<<100.0*jief.efficiency()<<" percent.\n";
}。