PTA-继承与派生

作者 黄万丽

单位 曲阜师范大学

在多继承中，派生类的构造函数需要依次调用其基类的构造函数，调用顺序取决于定义派生类时所指定的各基类的顺序。(T)

作者 黄万丽

单位 曲阜师范大学

基类与派生类对象之间具有赋值兼容的关系，可以进行类型间的转换，派生类对象可以直接转换为基类对象，同样基类对象也可以直接转换为派生类对象 。(F)

作者 黄万丽

单位 曲阜师范大学

如果函数的参数是基类对象或基类对象的引用，函数调用时的实参可以是派生类对象。(T)

作者 黄淑伟

单位 沈阳师范大学

如果公有派生，则可以用派生类对象给基类对象赋值。(T)

作者 黄淑伟

单位 沈阳师范大学

如果公有派生，则可以用基类对象初始化派生类的引用。(F)

作者 黄淑伟

单位 沈阳师范大学

如果公有派生，则可以用基类对象的地址赋值给派生类的指针。(F)

作者 李廷元

单位 中国民用航空飞行学院

可以用p.a的形式访问派生类对象p的基类成员a, 其中a是（D)

A.私有继承的公有成员

B.公有继承的私有成员

C.公有继承的保护成员

D.公有继承的公有成员

作者 李廷元

单位 中国民用航空飞行学院

下面关于类的继承与派生的程序，其输出结果是(C)

#include<iostream>
using namespace std;
class A {
public:
    A(int i) {    x = i;  }
    void dispa() {
        cout << x << ',';
    }
private:
    int x;
};
class B: public A {
public:
    B(int i) : A(i + 10) {
        x = i;
    }
    void dispb() {
        dispa();
        cout << x << endl;
    }
private:
    int x;
};
int main() {
    B b(2);
    b.dispb();
    return 0;
}

A.10,2

B.12,10

C.12,2

D.2,2

作者 李廷元

单位 中国民用航空飞行学院

若obj是类D的对象，则下列语句中正确的是(D)

class B{
private: void fun1(){ }
protected: void fun2(){ }
public: void fun3(){ }
};
class D : public B {
protected: void fun4(){ }
};

A.obj.fun1();

B.obj.fun2();

C.obj.fun4();

D.obj.fun3();

作者 李廷元

单位 中国民用航空飞行学院

在下列关键字中，不能用来表示继承方式的是(C)

A.private

B.public

C.static

D.protected

作者 李廷元

单位 中国民用航空飞行学院

下面关于继承和派生的构造函数和析构函数的程序，输出结果是(B)

#include<iostream>
using namespace std;
class AA {
public:
    AA() { cout << "A"; }
    ~AA() { cout << "a"; }
};
class BB: public AA {
    AA aa;
public:
    BB() { cout << "B"; }
    ~BB() { cout << "b"; }
};
int main() {
    BB bb;
    return 0;
}

A.AABaab

B.AABbaa

C.BAAaab

D.BAAbaa

作者 王秀

单位 福州大学

假设在公有派生情况下，以下说法不正确的是(A)

A.可以将基类对象复制给派生类对象

B.可以将派生类对象的地址复制给基类指针

C.可以将派生类对象赋值给基类的引用

D.可以将派生类对象赋值给基类对象

作者 黄万丽

单位 曲阜师范大学

多继承是指（A）。

A.一个派生类同时继承多个基类

B.多个派生类同时继承一个基类

C.基类本身又是一个更高一级基类的派生类

D.派生类本身又是更低一级派生类的基类

作者 范鹏程

单位 内蒙古师范大学

在公有派生情况下，有关派生类对象和基类对象的关系，下列叙述不正确的是(C)

A.派生类的对象可以赋给基类的对象

B.派生类的对象可以初始化基类的引用

C.派生类的对象可以直接访问基类中的成员

D.派生类的对象的地址可以赋给指向基类的指针

作者 李志明

单位 燕山大学

下面，有关派生类构造函数的论述，错误的是（C）

A.派生类构造函数，需要为基类构造函数传递参数；

B.派生类构造函数，需要为内嵌子对象的初始化传递参数；

C.派生类构造函数，仅对派生类的新增数据成员初始化传递参数；

D.派生类构造函数，可以采用初始化列表的方式为常成员函数传递初始化参数。

作者 李志明

单位 燕山大学

派生类的对象对它的基类成员中（A）是可以访问的。

A.公有继承的公有成员

B.公有继承的私有成员

C.公有继承的保护成员

D.私有继承的公有成员

作者 李志明

单位 燕山大学

C++类体系中，不能被派生类继承的有(A)。

A.析构函数

B.虚函数

C.静态成员函数

D.常成员函数

作者 董俊

单位 燕山大学

创建一个类A；然后通过继承的方式由类A派生出类B，则下列关于派生中构造函数和析构函数的描述中正确的是：C

A.类B继承了类A的构造函数

B.类B继承了类A的析构函数

C.创建类B的对象时，先执行类A的构造函数，然后执行类B的构造函数

D.撤销类B的对象时，先执行类A的析构函数，然后执行类B的析构函数

作者 董俊

单位 燕山大学

下列有关类型兼容规则的描述中，错误的是：D

A.派生类的对象可以隐含转换为基类对象

B.派生类的对象可以初始化基类的引用

C.派生类的指针可以隐含转换为基类的指针

D.派生类的对象可以被基类的对象初始化

作者 黄淑伟

单位 沈阳师范大学

以下说法正确的是(C)

A.子对象都是通过无参构造函数初始化的

B.派生类对象的构造函数是先于基类的构造函数被调用的

C.由多个基类派生时,基类构造函数的调用顺序,取决于定义派生类时,派生列表中的基类声明顺序

D.由多个基类派生时,子对象所属类的构造函数调用顺序,取决于基类的定义顺序

作者 黄淑伟

单位 沈阳师范大学

如果多种事物，有一些共同的特点又各自不同的特点，如何编写类来代表这些事物比较合适？(C)

A.为每种事物独立编写一个类，各之间互相无关

B.写一个类代表其中一种事物，代表其他事物的类都从这个类派生出来

C.概括所有事物的共同特点，写一个基类。然后为每种事物写一个类，都从基派生而来

D.一共就写一个类，包含所有事物的所有特点，然后用一个成员变量作为标记，来区分不同种类的事物

作者 xuwz

单位 广东东软学院

若派生类的成员函数不能直接访问基类中的某个成员，则该成员一定是基类中的（A）。

A.私有成员

B.公有成员

C.保护成员

D.私有成员或保护成员

作者 xuwz

单位 广东东软学院

在创建派生类对象时，构造函数的执行顺序是(B)。

A.对象成员构造函数、基类构造函数、派生类本身的构造函数

B.基类构造函数、对象成员构造函数、派生类本身的构造函数

C.基类构造函数、派生类本身的构造函数、对象成员构造函数

D.派生类本身的构造函数、基类构造函数、对象成员构造函数

作者 李祥

单位 湖北经济学院

派生类中的私有成员

若采用私有继承方式，则派生类对象中的私有成员不可能为 ▁▁▁A▁▁。

A.基类中定义的私有成员

B.基类中定义的保护成员

C.基类中定义的公有成员

D.派生类中新增的私有成员

作者 DS&A课程组

单位 燕山大学

派生类的成员函数不能访问基类的（C）

A.共有成员和保护成员

B.保护成员

C.私有成员

D.共有成员

作者 董卫萍

单位 绍兴文理学院元培学院

下面对派生类的描述中，错误的是(D)

A.一个派生类可以作为另外一个派生类的基类

B.派生类至少有一个基类

C.派生类的成员除了它自己的成员外，还包含了它的基类的成员

D.派生类中继承的基类成员的访问权限到派生类中保持不变

作者 董卫萍

单位 绍兴文理学院元培学院

下列关于派生类构造函数和析构函数的说法中，错误的是（D）

A.派生类的构造函数会隐含调用基类的构造函数

B.如果基类中有默认构造函数，派生类可以不定义构造函数

C.在建立派生类对象时，先调用基类的构造函数，再调用派生类的构造函数

D.在销毁派生类对象时，先调用基类的析构函数，再调用派生类的析构函数

作者 董卫萍

单位 绍兴文理学院元培学院

为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为（A）

A.public

B.protected

C.private

D.static

作者 李祥

单位 湖北经济学院

基类成员在派生类中的访问属性

基类中的私有成员在私有派生类中的访问属性为 ▁▁▁D▁▁。

A.私有

B.保护

C.公有

D.无法访问

作者 李祥

单位 湖北经济学院

基类成员在派生类中的访问属性

基类中的私有成员在保护派生类中的访问属性为 ▁▁D▁▁▁。

A.私有

B.保护

C.公有

D.无法访问

作者 李祥

单位 湖北经济学院

基类成员在派生类中的访问属性

基类中的私有成员在公有派生类中的访问属性为 ▁▁D▁▁▁。

A.私有

B.保护

C.公有

D.无法访问

作者 李祥

单位 湖北经济学院

基类成员在派生类中的访问属性

基类中的保护成员在私有派生类中的访问属性为 ▁▁A▁▁▁。

A.私有

B.保护

C.公有

D.无法访问

作者 李祥

单位 湖北经济学院

基类成员在派生类中的访问属性

基类中的保护成员在保护派生类中的访问属性为 ▁▁B▁▁▁。

A.私有

B.保护

C.公有

D.无法访问

作者 李祥

单位 湖北经济学院

基类成员在派生类中的访问属性

基类中的保护成员在公有派生类中的访问属性为 ▁▁B▁▁▁。

A.私有

B.保护

C.公有

D.无法访问

作者 李祥

单位 湖北经济学院

基类成员在派生类中的访问属性

基类中的公有成员在私有派生类中的访问属性为 ▁▁A▁▁▁。

A.私有

B.保护

C.公有

D.无法访问

作者 李祥

单位 湖北经济学院

基类成员在派生类中的访问属性

基类中的公有成员在保护派生类中的访问属性为 ▁▁B▁▁▁。

A.私有

B.保护

C.公有

D.无法访问

作者 李祥

单位 湖北经济学院

基类成员在派生类中的访问属性

基类中的公有成员在公有派生类中的访问属性为 ▁▁C▁▁▁。

A.私有

B.保护

C.公有

D.无法访问

作者 李祥

单位 湖北经济学院

关于赋值兼容关系

已知 BASE 为基类，DERIVED 为公有派生类，有下面的函数声明

void F(BASE *p);
void G(DERIVED *p);

若 a 为基类对象，b 为派生类对象，则 ▁▁C▁▁▁ 是错误的用法。

A.F(&a)

B.F(&b)

C.G(&a)

D.G(&b)

作者 李祥

单位 湖北经济学院

关于赋值兼容关系

已知 BASE 为基类，DERIVED 为公有派生类，有下面的函数声明

void F(BASE &x);
void G(DERIVED &x);

若 a 为基类对象，b 为派生类对象，则 ▁▁▁C▁▁ 是错误的用法。

A.F(a)

B.F(b)

C.G(a)

D.G(b)

作者 李祥

单位 湖北经济学院

关于赋值兼容规则

赋值兼容规则是指在需要基类对象的任何地方, 都可以使用 ▁▁C▁▁▁ 派生类的对象来替代。

A.私有

B.保护

C.公有

D.任何

作者 李廷元

单位 中国民用航空飞行学院

下列程序的执行结果为C

#include <iostream>
using namespace std;

class A {
public:
    A() {     cout << "1";    }
    ~A() {    cout << "2";    }
};
class B: public A {
public:
    B() {    cout << "3";    }
    ~B() {    cout << "4";    }
};
int main() {
    B b;
    return 0;
}

A.1234

B.1324

C.1342

D.3142

作者 李廷元

单位 中国民用航空飞行学院

下列关于派生类构造函数和析构函数的说法中，错误的是(D)

A.派生类的构造函数会隐含调用基类的构造函数

B.如果基类声明了带有形参表的构造函数，则派生类就应当声明构造函数

C.在建立派生类对象时，先调用基类的构造函数，再调用派生类的构造函数

D.在销毁派生类对象时，先调用基类的析构函数，再调用派生类的析构函数

作者 李廷元

单位 中国民用航空飞行学院

建立派生类对象时, 3种构造函数分别是a(基类的构造函数)、b(成员对象的构造函数)、c(派生类的构造函数)，这3种构造函数的调用顺序为(A)

A.abc

B.acb

C.cab

D.cba

作者 李廷元

单位 中国民用航空飞行学院

下面关于类的继承与派生的程序，其输出结果是(D)

#include<iostream>
using namespace std;
class A
{
public:
    A(){cout<<"A";}
};
class B
{
public:
    B(){cout<<"B";}
};
class C:public A
{
    B b;
public:
    C(){cout<<"C";}
};
int main(){
    C obj;
    return 0;
}

A.CBA

B.BAC

C.ACB

D.ABC

作者 黄淑伟

单位 沈阳师范大学

以下说法正确的是？(C)

A.派生类对象生成时，派生类的构造函数先于基类的构造函数执行

B.派生类对象消亡时，基类的析构函数先于派生类的析构函数执行

C.如果基类有无参构造函数，则派生类的构造函数就可以不带初始化列表

D.在派生类的构造函数中，可以访问基类的成员变量

作者 何振峰

单位 福州大学

一个类的私有成员(B)

A.只能被该类的成员函数访问

B.只能被该类的成员函数和友元函数访问

C.只能被该类的成员函数、友元函数和派生类访问

D.以上答案都不对

作者 何振峰

单位 福州大学

在派生类对基类继承的传递性中，_C_是错误的。

A.在公有继承方式下，直接派生类对象可以直接调用基类中的公有成员函数，去访问基类的私有数据成员

B.在公有继承方式下，间接派生类对象可以直接调用基类中的公有成员函数，去访问基类的私有数据成员

C.在私有继承方式下，间接派生类对象可以直接调用基类中的公有成员函数，去访问基类的私有数据成员

D.不管是私有继承还是公有继承，基类中的私有成员在派生类的作用域内都是不可能见的。

作者 李廷元

单位 中国民用航空飞行学院

继承机制的作用是C

A.信息隐藏

B.数据封装

C.定义新类

D.数据抽象

作者 李廷元

单位 中国民用航空飞行学院

C++语言类体系中, 不能被派生类继承的有B

A.转换函数

B.构造函数

C.虚函数

D.静态成员函数

作者 李廷元

单位 中国民用航空飞行学院

在公有继承的情况下，在派生类中能够访问的基类成员包括D

A.公有成员

B.保护成员

C.公有成员、保护成员和私有成员

D.公有成员和保护成员

作者 李廷元

单位 中国民用航空飞行学院

下面叙述不正确的是A

A.基类的保护成员在派生类中仍然是保护的成员

B.基类的保护成员在公有派生类中仍然是保护的

C.基类的保护成员在私有派生类中仍然是私有的

D.对基类成员的访问必须是无二义性

作者 李廷元

单位 中国民用航空飞行学院

派生类继承基类的方式有D

A.public

B.private

C.protected

D.以上都对

作者 李廷元

单位 中国民用航空飞行学院

下列关于继承的描述中，错误的是(D)

A.析构函数不能被继承

B.派生类是基类的组合

C.派生类的成员除了它自己的成员外，还包含了它的基类的成员

D.派生类中继承的基类成员的访问权限到派生类保持不变

作者 黄淑伟

单位 沈阳师范大学

以下说法不正确的是（假设在公有派生情况）？(A)

A.可以将基类对象赋值给派生类对象

B.可以将派生类对象的地址赋值给基类指针

C.可以将派生类对象赋值给基类的引用

D.可以将派生类对象赋值给基类对象

作者 孙杰

单位 青岛大学

设有基类定义：
class Cbase
{ private: int a;
protected: int b;
public: int c;
};派生类采用何种继承方式可以使成员变量b成为自己的私有成员(C)

A.保护继承

B.公有继承

C.私有继承

D.私有、保护、公有均可

作者 葛亮

单位 重庆大学

父类Base和子类Derive的定义如下。请问在子类中，继承的父类成员f，x，y的访问控制权限分别是：D

class Base
{
    public:
        void f();
    protected:
        int x;
    private:
        int y;
};

class Derive : protected Base
{
};

A.public, protected, private

B.public, public, public

C.private, private, private

D.protected, protected, private

作者 李志明

单位 燕山大学

class X{
int a;
public:
X(int x=0) {a=x;}
};
class Y:public X {
int b;
public:
Y(int x=0,int y=0):X(y)) { b=x;}
};
下述语句存在错误的是（B）

A.X *pa=new Y(1,2);

B.X a1=Y(1,3);

C.Y b1(2,3); X & a3=b1;

D.X a4(10); Y b2=a4;

#include <iostream> #include<string> using namespace std; class Student
{

public:
        Student(int n, string nam )
        { num=n; name=nam; }

        void display()
        {

                cout<<"num:"<<num<<endl; cout<<"name:"<<name<<endl;

        }

         protected:
                int num;
                string name;

};

class Student1: public Student
{

         public:

        Student1(int n,string nam,int a):Student(n,nam)

          {  age=a; }
        void show( )
        {

                display();
                cout<<"age: "<<age<<endl;        

        }

        private:
                int age;
};

class Student2:public Student1
{

        public: Student2(int n, string nam, int a, int s):Student1(n, nam, a) { score=s; }

        void show_all()
        {

                show();
                cout<<"score:"<<score<<endl;
        }

        private: int score;
};

int main( )

{

        Student2 stud(10010, "Li", 17, 89); stud.show_all( );
        return 0;

}

6-1 狗的继承

作者 杨军

单位 四川师范大学

完成两个类，一个类Animal，表示动物类，有一个成员表示年龄。一个类Dog，继承自Animal，有一个新的数据成员表示颜色，合理设计这两个类，使得测试程序可以运行并得到正确的结果。

函数接口定义：

按照要求实现类

裁判测试程序样例：

/* 请在这里填写答案 */ int main(){ Animal ani(5); cout<<"age of ani:"<<ani.getAge()<<endl; Dog dog(5,"black"); cout<<"infor of dog:"<<endl; dog.showInfor(); }

输入样例：

无

输出样例：

age of ani:5
infor of dog:
age:5
color:black

解答：

#include <bits/stdc++.h>
using namespace std;
class Animal
{
    private:
    int age;
    public:
    Animal(int a)
    {
        age=a;
    }
    int getAge()
    {
        return age;
    }
};
class Dog:public Animal
{
    private:
    string color;
    public:
    Dog(int age,string c):Animal(age)
    {
        color=c;
    }
    void showInfor()
    {
        cout<<"age:"<<getAge()<<endl<<"color:"<<color<<endl;
    }
}; 

6-2 使用类输出图形

作者 刘骥

单位 重庆大学

声明一个图形基类 Shape，在它的基础上派生出矩形类 Rectangle 和圆形类 Circle，他们都有计算面积和周长、输出图形信息等成员函数，再在 Rectangle 类的基础上派生出正方形类 Square。编写程序完成各类的定义和实现，以及类的使用。
注意：
题目中定义的所有数值类型的变量都使用 double 类型
π的值为 3.14159

测试程序样例：

#include <iostream> #define PI 3.14159 using namespace std; class Shape{ public: double getArea(){return 0;} double getPerimeter(){return 0;} }; class Rectangle:public Shape { protected: double height; double width; public: Rectangle() {}; Rectangle(double _height, double _width) { height = _height; width = _width; } double getArea(){ return height * width; } double getPerimeter(){ return 2 * (height + width); } void Print(){ cout << "Width=" << width << ",Height=" << height << endl; } }; /* 请在这里填写答案 */ int main() { double ra, rb; cin >> ra >> rb; Rectangle r1(ra, rb); double sa; cin >> sa; Square s1(sa); double ca, cb, cc; cin >> ca >> cb >> cc; Circle c1(ca, cb, cc); cout << "Rectangle" << endl; r1.Print(); cout << "Area=" << r1.getArea() << endl; cout << "Perimeter=" << r1.getPerimeter() << endl ; cout << "Square" << endl; s1.Print(); cout << "Area=" << s1.getArea() << endl; cout << "Perimeter=" << s1.getPerimeter() << endl; cout << "Circle" << endl; c1.Print(); cout << "Area=" << c1.getArea() << endl; cout << "Perimeter=" << c1.getPerimeter() << endl; return 0; }

输入样例：

在这里给出一组输入。例如：

4 2.5
8
4 5 6.5

输出样例：

Rectangle
Width=2.5,Height=4
Area=10
Perimeter=13
Square
Side=8
Area=64
Perimeter=32
Circle
Center=[4,5],Adius=6.5
Area=132.732
Perimeter=40.8407

提示

需要补充的类定义如下：

class Square:public Rectangle{ //...... }; class Circle: public Shape{ //...... };

解答：

class Square:public Rectangle
{
    private:
    int side;
    public:
    Square(int s)
    {
        side = s;
    }
    void Print()
    {
        cout<<"Side="<<side<<endl;
    }
    int getArea()
    {
        return side*side;
    }
    int getPerimeter()
    {
        return 4*side;
    }
};
class Circle:public Shape
{
    private:
    int x;
    int y;
    float adius;
    public:
    Circle(int x1,int y1,float a)
    {
        x=x1;
        y=y1;
        adius=a;
    }
    void Print()
    {
        cout<<"Center=["<<x<<","<<y<<"],Adius="<<adius<<endl;
    }
    double getArea()
    {
        return PI*adius*adius;
    }
    double getPerimeter()
    {
        return 2*PI*adius;
    }
};

6-3 派生类的定义和使用

作者 李廷元

单位 中国民用航空飞行学院

按要求完成下面的程序：

1、定义一个Animal类，包含一个void类型的无参的speak方法，输出“animal language!”。

2、定义一个Cat类，公有继承自Animal类，其成员包括：

（1）私有string类型的成员m_strName;

（2）带参数的构造函数，用指定形参对私有数据成员进行初始化；

（3）公有的成员函数print_name，无形参，void类型，功能是输出成员m_strName的值，具体输出格式参见main函数和样例输出。

类和函数接口定义：

参见题目描述。

裁判测试程序样例：

#include <iostream> #include <string> using namespace std; /* 请在这里填写答案 */ int main() { Cat cat("Persian"); //定义派生类对象 cat.print_name(); //派生类对象使用本类成员函数 cat.speak(); //派生类对象使用基类成员函数 return 0; }

输入样例：

本题无输入。

输出样例：

cat name: Persian
animal language!

 解答：

class Animal
{
    public:
    void speak()
    {
        cout<<"animal language!"<<endl;
    }
};
class Cat:public Animal
{
    private:
    string m_strName;
    public:
    Cat(string s)
    {
        m_strName=s;
    }
    void print_name()
    {
        cout<<"cat name: "<<m_strName<<endl;
    }
};

6-4 派生类使用基类的成员函数

作者 李廷元

单位 中国民用航空飞行学院

按要求完成下面的程序：

1、定义一个Animal类，成员包括：

（1）整数类型的私有数据成员m_nWeightBase，表示Animal的体重；

（2）整数类型的保护数据成员m_nAgeBase，表示Animal的年龄；

（3）公有函数成员set_weight，用指定形参初始化数据成员nWeightBase；

（4）公有成员函数get_weight，返回数据成员nWeightBase的值；

（5）公有函数成员set_age，用指定形参初始化数据成员m_nAgeBase；

2、定义一个Cat类，公有继承自Animal类，其成员包括：

（1）string类型的私有数据成员m_strName;

（2）带参数的构造函数，用指定形参对私有数据成员进行初始化；

（3）公有的成员函数print_age，功能是首先输出成员m_strName的值，然后输出“, age = ”，接着输出基类的数据成员m_nAgeBase的值。具体输出格式参见main函数和样例输出。

类和函数接口定义：

参见题目描述。

裁判测试程序样例：

#include <iostream> #include <string> using namespace std; /* 请在这里填写答案 */ int main() { Cat cat("Persian"); //定义派生类对象cat cat.set_age(5); //派生类对象调用从基类继承的公有成员函数 cat.set_weight(6); //派生类对象调用从基类继承的公有成员函数 cat.print_age(); //派生类对象调用自己的公有函数 cout << "cat weight = " << cat.get_weight() << endl; return 0; }

输入样例：

本题无输入。

输出样例：

Persian, age = 5
cat weight = 6

解答：

class Animal
{
    private:
    int m_nWeightBase;
    protected:
    int m_nAgeBase;
    public:
    void set_weight(int w)
    {
        m_nWeightBase=w;
    }
    int get_weight()
    {
        return m_nWeightBase;
    }
    void set_age(int a)
    {
        m_nAgeBase=a;
    }
};
class Cat:public Animal
{
    private:
    string m_strName;
    public:
    Cat(string s)
    {
        m_strName=s;
    }
    void print_age()
    {
        cout<<m_strName<<", age = "<<m_nAgeBase<<endl;
    }
};

6-5 私有继承派生类使用基类的成员函数

作者 李廷元

单位 中国民用航空飞行学院

按要求完成下面的程序：

1、定义一个Animal类，成员包括：

（1）整数类型的私有数据成员m_nWeightBase，表示Animal的体重；

（2）整数类型的保护数据成员m_nAgeBase，表示Animal的年龄；

（3）公有函数成员set_weight，用指定形参初始化数据成员m_nWeightBase；

（4）公有成员函数get_weight，返回数据成员m_nWeightBase的值；

（5）公有函数成员set_age，用指定形参初始化数据成员m_nAgeBase；

2、定义一个Cat类，私有继承自Animal类，其成员包括：

（1）string类型的私有数据成员m_strName;

（2）带参数的构造函数，用指定形参对私有数据成员进行初始化
；
（3）公有的成员函数set_print_age，功能是首先调用基类的成员函数set_age设置数据成员m_nAgeBase的值为5，接着输出成员m_strName的值，然后输出“, age = ”，最后输出基类的数据成员m_nAgeBase的值。具体输出格式参见main函数和样例输出。

（4）公有的成员函数set_print_weight，功能是首先调用基类的成员函数set_weight设置数据成员nWeightBase的值为6，接着输出成员m_strName的值，然后输出“, weight = ”，最后调用基类的成员函数get_weight输出基类的数据成员m_nAgeBase的值。具体输出格式参见main函数和样例输出。

类和函数接口定义：

参见题目描述。

裁判测试程序样例：

#include <iostream> #include <string> using namespace std; /* 请在这里填写答案 */ int main() { Cat cat("Persian"); //定义派生类对象cat cat.set_print_age(); cat.set_print_weight(); //派生类对象调用自己的公有函数 return 0; }

输入样例：

本题无输入。

输出样例：

Persian, age = 5
Persian, weight = 6

 解答：

class Animal
{
    private:
    int m_nWeightBase;
    protected:
    int m_nAgeBase;
    public:
    void set_weight(int w)
    {
        m_nWeightBase=w;
    }
    int get_weight()
    {
        return m_nWeightBase;
    }
    void set_age(int a)
    {
        m_nAgeBase=a;
    }
};
class Cat:private Animal
{
    private:
    string m_strName;
    public:
    Cat(string s)
    {
        m_strName=s;
    }
    void set_print_age()
    {
        Animal::set_age(5);
        cout<<m_strName<<", age = "<<m_nAgeBase<<endl;
    }
    void set_print_weight()
    {
        Animal::set_weight(6);
        cout<<m_strName<<", weight = "<<get_weight()<<endl;
    }
};

6-6 多重继承派生类构造函数

作者 范鹏程

单位 内蒙古师范大学

根据所给的基类Student和Teacher，定义Graduate类

类定义：

#include <iostream> #include <string> using namespace std; class Teacher {public: Teacher(string nam,int a,string t) {name=nam; age=a; title=t;} void display() {cout<<"name:"<<name<<endl; cout<<"age"<<age<<endl; cout<<"title:"<<title<<endl; } protected: string name; int age; string title; }; class Student {public: Student(string nam,char s,float sco) {name1=nam; sex=s; score=sco;} void display1() {cout<<"name:"<<name1<<endl; cout<<"sex:"<<sex<<endl; cout<<"score:"<<score<<endl; } protected: string name1; char sex; float score; }; /* 请在这里填写答案 */

裁判测试程序样例：

int main( ) {Graduate grad1("Wang-li",24,'f',"assistant",89.5,1234.5); grad1.show( ); return 0; }

输出样例：

name:Wang-li
age:24
sex:f
score:89.5
title:assistant
wages:1234.5

解答：

class Graduate:public Teacher,public Student
{
    private:
    float wage;
    public:
    Graduate(string name,int age,char sex,string title,float score,float w):Teacher(name,age,title),Student(name,sex,score)
    {
        wage=w;
    }
    void show()
    {
        cout<<"name:"<<name<<endl;
        cout<<"age:"<<age<<endl;
        cout<<"sex:"<<sex<<endl;
        cout<<"score:"<<score<<endl;
        cout<<"title:"<<title<<endl;
        cout<<"wages:"<<wage<<endl;
    }
};

6-7 汽车类的继承

作者 范鹏程

单位 内蒙古师范大学

根据给定的汽车类vehicle（包含的数据成员有车轮个数wheels和车重weight）声明，完成其中成员函数的定义，之后再定义其派生类并完成测试。

小车类car是它的派生类，其中包含载人数passenger_load。每个类都有相关数据的输出方法。

###Vehicle类声明如下：

#include<iostream>
using namespace std; 
class Vehicle 
{ 
    protected: 
        int wheels; 
        float weight; 
    public: 
        Vehicle(int wheels,float weight); 
        int get_wheels(); 
        float get_weight(); 
        float wheel_load(); 
        void show(); 
}; 

/* 请在这里填写答案 */

裁判测试程序样例：

int main () { Vehicle v(4,1000); v.show(); Car car1(4,2000,5); car1.show (); return 0; }

输出样例：

在这里给出相应的输出。例如：

Type:Vehicle
Wheel:4
Weight:1000kg
Type:Car
Type:Vehicle
Wheel:4
Weight:2000kg
Load:5 persons

解答：

Vehicle::Vehicle(int wh,float we)
{
    this->wheels=wh;
    this->weight=we;
}
int Vehicle::get_wheels()
{
    return wheels;
}
float Vehicle::get_weight()
{
    return weight;
}
float Vehicle::wheel_load()
{
    ;
}
void Vehicle::show()
{
    cout<<"Type:Vehicle"<<endl;
    cout<<"Wheel:"<<get_wheels()<<endl;
    cout<<"Weight:"<<get_weight()<<"kg"<<endl;
}
class Car:public Vehicle
{
    private:
    int passenger_load;
    public:
    Car(int wheels,int weight,int p):Vehicle(wheels,weight)
    {
        passenger_load=p;
    }
    void show()
    {
        cout<<"Type:Car"<<endl;
        cout<<"Type:Vehicle"<<endl;
        cout<<"Wheel:"<<get_wheels()<<endl;
        cout<<"Weight:"<<get_weight()<<"kg"<<endl;
        cout<<"Load:"<<passenger_load<<" persons"<<endl;
    }
};

6-8 鸭子也是鸟

作者 fpc

单位 内蒙古师范大学

按要求完成下面的程序：

1、定义一个Bird类，包含一个void类型的无参的speak方法，输出“Jiu-Jiu-Jiu”。

2、定义一个Duck类，公有继承自Bird类，其成员包括：

（1）私有string类型的成员name;

（2）带参数的构造函数，用指定形参对私有数据成员进行初始化；

（3）公有的成员函数printName，无形参，void类型，功能是输出成员name的值，具体输出格式参见main函数和样例输出。

裁判测试程序样例：

#include <iostream>
#include <string>
using namespace std;

/* 请在这里填写答案 */

int main()
{
    Bird b;
    b.speak();
    Duck d("Donald"); //定义派生类对象
    d.printName();    //派生类对象使用本类成员函数
    d.speak();    //派生类对象使用基类成员函数
    return 0;
}

输入样例：

无输入

输出样例：

Jiu-Jiu-Jiu
Dird Name:Donald
Jiu-Jiu-Jiu

 解答：

class Bird
{
    public:
    void speak()
    {
        cout<<"Jiu-Jiu-Jiu"<<endl;
    }
};
class Duck:public Bird
{
    private:
    string name;
    public:
    Duck(string n)
    {
        name=n;
    }
    void printName()
    {
        cout<<"Dird Name:"<<name<<endl;
    }
};