hznu.dodo 实验九 继承和多态

1.

【描述】
①声明并实现一个名为Vehicle的基类，表示汽车。Vehicle类包括：
int类型的私有数据成员numberOfDoors，表示车门数量。
int类型的私有数据成员numberOfCylinders，表示气缸数量。
string类型的私有数据成员color，表示汽车颜色。
double类型的私有数据成员fuelLevel，表示油位，即燃油数量。
int类型的私有数据成员transmissionType，表示变速箱类型，即0表示手动、1表示自动。
string类型的私有数据成员className，表示汽车类别。
有参构造函数，将车门数量、气缸数量、汽车颜色、燃油数量、变速箱类型设置为给定的参数。
访问器函数getNumberOfDoors、getNumberOfCylinders、getColor、getFuelLevel、getTransmissionType、getClassNme，分别用于访问车门数量、气缸数量、汽车颜色、燃油数量、变速箱类型、汽车类别。
更改器函数setColor、setFuelLevel、setClassNme，分别用于更改汽车颜色、燃油数量、汽车类别。
重载流插入运算符<<，输出相关信息。
②从Vehicle类派生出Taxi类，表示出租车。Taxi类有数据成员customers（是否载客，bool类型）以及有参构造函数，将车门数量、气缸数量、汽车颜色、燃油数量、变速箱类型、是否载客设置为给定的参数；访问器/更改器函数hasCustomers和setCustomers；重载流插入运算符<<，输出相关信息。
③从Vehicle类派生出Truck类，表示卡车。Truck类有数据成员cargo（是否载货，bool类型）以及有参构造函数，将车门数量、气缸数量、汽车颜色、燃油数量、变速箱类型、是否载货设置为给定的参数；访问器/更改器函数hasCargo和setCargo；重载流插入运算符<<，输出相关信息。
【输入】
输入车门数量、气缸数量，颜色、燃油数量、变速箱类型。
【输出】
见【输出示例】
【输入示例】

2 6 red 50 1
4 6 yellow 60 0
2 16 black 100 0

【输出示例】

Vehicle
Number of doors:2
Number of cylinders:6
Transmission type:Automatic
Color:red
Fuel level:50
Taxi
Number of doors:4
Number of cylinders:6
Transmission type:Manual
Color:yellow
Fuel level:60
Has no passengers
Truck
Number of doors:2
Number of cylinders:16
Transmission type:Manual
Color:black
Fuel level:100
Is carrying cargo

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

/* 请在此处分别编写Vehicle、Taxi和Truck类 */

class Vehicle {
private:
    int numberOfDoors;
    int numberOfCylinders;
    string color;
    double fuelLevel;
    int transmissionType;
    string className;

public:
    Vehicle(int doors, int cylinders, const string& col, double fuel, int transmission)
        : numberOfDoors(doors), numberOfCylinders(cylinders), color(col), 
          fuelLevel(fuel), transmissionType(transmission), className("Vehicle") {}

 
    int getNumberOfDoors() const { return numberOfDoors; }
    int getNumberOfCylinders() const { return numberOfCylinders; }
    string getColor() const { return color; }
    double getFuelLevel() const { return fuelLevel; }
    int getTransmissionType() const { return transmissionType; }
    string getClassName() const { return className; }

 
    void setColor(const string& col) { color = col; }
    void setFuelLevel(double fuel) { fuelLevel = fuel; }
    void setClassNme(const string& className) { this->className = className; }

   
    friend ostream& operator<<(ostream& os, const Vehicle& v) {
        os << v.className << endl;
        os << "Number of doors:" << v.numberOfDoors << endl;
        os << "Number of cylinders:" << v.numberOfCylinders << endl;
        os << "Transmission type:" << (v.transmissionType == 0 ? "Manual" : "Automatic") << endl;
        os << "Color:" << v.color << endl;
        os << "Fuel level:" << v.fuelLevel << endl;
        return os;
    }
};


class Taxi : public Vehicle {
private:
    bool customers; 

public:

    Taxi(int doors, int cylinders, const string& col, double fuel, int transmission, bool hasCustomers)
        : Vehicle(doors, cylinders, col, fuel, transmission), customers(hasCustomers) {
        setClassNme("Taxi");
    }

    bool hasCustomers() const { return customers; }

    void setCustomers(bool hasCustomers) { customers = hasCustomers; }

    friend ostream& operator<<(ostream& os, const Taxi& t) {
        os << (Vehicle)t; 
        os << (t.customers ? "Has passengers" : "Has no passengers") << endl;
        return os;
    }
};

class Truck : public Vehicle {
private:
    bool cargo;

public:
    Truck(int doors, int cylinders, const string& col, double fuel, int transmission, bool hasCargo)
        : Vehicle(doors, cylinders, col, fuel, transmission), cargo(hasCargo) {
        setClassNme("Truck");
    }

    bool hasCargo() const { return cargo; }

    void setCargo(bool hasCargo) { cargo = hasCargo; }

    friend ostream& operator<<(ostream& os, const Truck& t) {
        os << (Vehicle)t; 
        os << (t.cargo ? "Is carrying cargo" : "Is not carrying cargo") << endl;
        return os;
    }
};

int main() {
    int doors, cylinders, transmission;
    string color;
    double fuel;
    cin >> doors >> cylinders >> color >> fuel >> transmission;
    Vehicle vehicle(doors, cylinders, color, fuel, transmission);
    cout << vehicle;
    cin >> doors >> cylinders >> color >> fuel >> transmission;
    Taxi taxi(doors, cylinders, color, fuel, transmission, false);
    cout << taxi;
    cin >> doors >> cylinders >> color >> fuel >> transmission;
    Truck truck(doors, cylinders, color, fuel, transmission, true);
    cout << truck;
    return 0;
}

2.

【描述】
①声明并实现一个名为Person的基类，Person类有保护数据成员name（姓名，string类型）、sex（性别，char类型，'M'表示男，'F'表示女）。以及有参构造函数，将姓名、性别设置为给定的参数；成员函数print，输出姓名和性别。
②从Person类派生出Student类，Student类有私有数据成员status（状态，枚举类型），表示年级（FRESHMAN、SOPHOMORE、JUNIOR、SENIOR），表示大一、大二、大三、大四学生。以及有参构造函数，将姓名、性别、状态设置为给定的参数；成员函数print，print函数输出姓名、性别和状态。
③定义MyDate类，它包含私有数据成员year、month和day以及带默认参数的有参构造函数，年、月、日的默认参数值分别为1900、1、1；成员函数print，输出年、月、日。
④从Person类派生出Employee类，Employee类有保护数据成员salary（薪水，int类型）、dateHired（雇佣日期），dataHired的类型是MyDate。以及有参构造函数，将姓名、性别、薪水和雇佣日期设置为给定的参数；成员函数print，输出姓名、性别、薪水和雇佣日期。
⑤从Employee类派生出Faculty类，Faculty类有私有数据成员rank（级别，枚举类型），有（PROFESSOR、ASSOCIATE_PROFESSOR、LECTURER），表示教授、副教授、讲师。以及有参构造函数，将姓名、性别、薪水、雇佣日期和级别设置为给定的参数；成员函数print，输出姓名、性别、薪水、雇佣日期和级别。
⑥从Employee类派生出Staff类，Staff类有私有数据成员headship（职务，枚举类型），有（PRESIDENT、DEAN、DEPARTMENT_CHAIRMAN），表示校长、院长、系主任。以及有参构造函数，将姓名、性别、薪水、雇佣日期和职务设置为给定的参数；成员函数print，输出姓名、性别、薪水、雇佣日期和职务。
【输入】
没有输入。
【输出】

Name:ZhangSan, Sex:M
Name:LiSi, Sex:F
Status:Freshman
Name:WangWu, Sex:M
Salary:5000, Hire date:2012-3-1
Name:LiuLiu, Sex:M
Salary:10000, Hire date:2012-3-1
Rank:Professor
Name:QianQi, Sex:M
Salary:8000, Hire date:2012-3-1
Headship:Department chairman

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

/* 请在此处分别编写Person、Student、MyDate、Employee、Faculty、Staff类 */
// 定义枚举类型
enum Status { FRESHMAN, SOPHOMORE, JUNIOR, SENIOR };
enum Rank { PROFESSOR, ASSOCIATE_PROFESSOR, LECTURER };
enum Headship { PRESIDENT, DEAN, DEPARTMENT_CHAIRMAN };

// ① Person类
class Person {
protected:
    string name;
    char sex;

public:
    Person(const string& name, char sex) : name(name), sex(sex) {}
    void print() const {
        cout << "Name:" << name << ", Sex:" << sex << endl;
    }
};

// ② Student类
class Student : public Person {
private:
    Status status;

public:
    Student(const string& name, char sex, Status status) : Person(name, sex), status(status) {}
    void print() const {
        Person::print();  // 输出姓名和性别
        cout << "Status:";
        switch (status) {
            case FRESHMAN: cout << "Freshman"; break;
            case SOPHOMORE: cout << "Sophomore"; break;
            case JUNIOR: cout << "Junior"; break;
            case SENIOR: cout << "Senior"; break;
        }
        cout << endl;
    }
};

// ③ MyDate类
class MyDate {
private:
    int year;
    int month;
    int day;

public:
    MyDate(int year = 1900, int month = 1, int day = 1) : year(year), month(month), day(day) {}
    
    void print() const {
        cout << year << "-" << month << "-" << day;
    }
};

// ④ Employee类
class Employee : public Person {
protected:
    int salary;
    MyDate dateHired;

public:
    Employee(const string& name, char sex, int salary, const MyDate& dateHired)
        : Person(name, sex), salary(salary), dateHired(dateHired) {}
    
    void print() const {
        Person::print();  // 输出姓名和性别
        cout << "Salary:" << salary << ", Hire date:";
        dateHired.print();
        cout << endl;
    }
};

// ⑤ Faculty类
class Faculty : public Employee {
private:
    Rank rank;

public:
    Faculty(const string& name, char sex, int salary, const MyDate& dateHired, Rank rank)
        : Employee(name, sex, salary, dateHired), rank(rank) {}
    
    void print() const {
        Employee::print();  // 输出姓名、性别、薪水和雇佣日期
        cout << "Rank:";
        switch (rank) {
            case PROFESSOR: cout << "Professor"; break;
            case ASSOCIATE_PROFESSOR: cout << "Associate Professor"; break;
            case LECTURER: cout << "Lecturer"; break;
        }
        cout << endl;
    }
};

// ⑥ Staff类
class Staff : public Employee {
private:
    Headship headship;

public:
    Staff(const string& name, char sex, int salary, const MyDate& dateHired, Headship headship)
        : Employee(name, sex, salary, dateHired), headship(headship) {}
    
    void print() const {
        Employee::print();  // 输出姓名、性别、薪水和雇佣日期
        cout << "Headship:";
        switch (headship) {
            case PRESIDENT: cout << "President"; break;
            case DEAN: cout << "Dean"; break;
            case DEPARTMENT_CHAIRMAN: cout << "Department chairman"; break;
        }
        cout << endl;
    }
};


int main() {
    Person person("ZhangSan", 'M');
    Student student("LiSi", 'F', FRESHMAN);
    MyDate date(2012, 3, 1);
    Employee employee("WangWu", 'M', 5000, date);
    Faculty faculty("LiuLiu", 'M', 10000, date, PROFESSOR);
    Staff staff("QianQi", 'M', 8000, date, DEPARTMENT_CHAIRMAN);
    person.print();
    student.print();
    employee.print();
    faculty.print();
    staff.print();
    return 0;
}

3.

【描述】
有5个类A、B、C、D、E。它们的形式均为：

class T {
public:
    T() {
        cout << "T()" << endl;
    }
    ~T() {
        cout << "~T()" << endl;
    }
}

这里T代表类名A、B、C、D、E。
给定如下main函数：

int main() {
    E e;
    return 0;
}

要求根据输出结果，声明并实现类A、B、C、D、E，确定类A、B、C、D、E之间的继承关系。
【输入】
没有输入。
【输出】

C()
B()
C()
A()
D()
E()
~E()
~D()
~A()
~C()
~B()
~C()

#include <iostream>
using namespace std;

/* 请在此处分别编写A、B、C、D、E类，注意：类A、B、C、D、E之间的继承关系 */
class C {
public:
    C() { cout << "C()" << endl; }
    ~C() { cout << "~C()" << endl; }
};

class B : public C {
public:
    B() { cout << "B()" << endl; }
    ~B() { cout << "~B()" << endl; }
};

class A : public C {
public:
    A() { cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }
};

class D : public A {
public:
    D() { cout << "D()" << endl; }
    ~D() { cout << "~D()" << endl; }
};

class E : public B, public D {
public:
    E() { cout << "E()" << endl; }
    ~E() { cout << "~E()" << endl; }
};

int main() {
    E e;
    return 0;
}

4.【描述】
①声明并实现一个名为Arc的类，在二维空间中以某一个点为中心，绘制圆弧。Arc类包含私有数据成员p（圆心，Point类型），radius（圆弧半径，double类型）；有参构造函数，将圆心、圆弧半径设置为给定的参数；成员函数draw，输出圆心和半径。
②声明并实现一个名为Circle的类，在二维空间中以某一个点为中心，绘制圆。Circle类包含私有数据成员p（圆心，Point类型），radius（圆半径，double类型）；有参构造函数，将圆心、圆半径设置为给定的参数；成员函数draw，输出圆心和半径。
③声明并实现一个名为Ellipse的类，在二维空间中以某一个点为中心，绘制椭圆。Ellipse类包含私有数据成员p（圆心，Point类型），xRadius、yRadius（椭圆轴，double类型）；有参构造函数，将圆心、椭圆轴设置为给定的参数；成员函数draw，输出圆心和轴。
④声明并实现一个名为Rectangle的类，在二维空间中以某一个点为左上角，绘制矩形。Rectangle类包含私有数据成员p（左上角坐标，Point类型），width、height（矩形宽度和高度，double类型）；有参构造函数，将左上角坐标、矩形宽度和高度设置为给定的参数；成员函数draw，输出左上角坐标和宽度、高度。
⑤声明并实现一个名为Mix的类，在二维空间中以某一个点为中心，绘制圆弧、圆、椭圆，以某一个点为左上角，绘制矩形。Mix类包含有参构造函数，将点坐标、圆弧半径、圆半径、椭圆轴、矩形宽度和高度设置为给定的参数；成员函数draw绘制圆弧、圆、椭圆和矩形，调用Arc类、Circle类、Ellipse类、Rectangle类的draw函数，输出相关信息。
Mix类是Arc类、Circle类、Ellipse类、Rectangle类的多继承派生类。
【输入】
没有输入。
【输出】

Drawing an arc: Center(320, 240), radius(100)
Drawing a circle: Center(320, 240), radius(70)
Drawing an ellipse: Center(320, 240), x-axis(100), y-axis(70)
Drawing a rectangle: Upper left corner coordinates(320, 240), width(100), height(70)

#include <iostream>
using namespace std;

/* 请在此处分别编写Point、Arc、Circle、Ellipse、Rectangle、Mix类 */ 
// 定义Point类  
class Point {  
private:  
    double x; // x坐标  
    double y; // y坐标  

public:  
    // 构造函数  
    Point(double x, double y) : x(x), y(y) {}  

    // 获取x坐标  
    double getX() const { return x; }  
    
    // 获取y坐标  
    double getY() const { return y; }  
};  

// 定义Arc类  
class Arc {  
private:  
    Point p;      // 圆心  
    double radius; // 圆弧半径  

public:  
    // 有参构造函数  
    Arc(const Point& center, double r) : p(center), radius(r) {}  

    // 成员函数，输出圆心和半径  
    void draw() const {  
        cout << "Drawing an arc: Center(" << p.getX() << ", " << p.getY() << "), radius(" << radius << ")" << endl;  
    }  
};  

// 定义Circle类  
class Circle {  
private:  
    Point p;      // 圆心  
    double radius; // 圆半径  

public:  
    // 有参构造函数  
    Circle(const Point& center, double r) : p(center), radius(r) {}  

    // 成员函数，输出圆心和半径  
    void draw() const {  
        cout << "Drawing a circle: Center(" << p.getX() << ", " << p.getY() << "), radius(" << radius << ")" << endl;  
    }  
};  

// 定义Ellipse类  
class Ellipse {  
private:  
    Point p;        // 圆心  
    double xRadius; // 椭圆的x轴半径  
    double yRadius; // 椭圆的y轴半径  

public:  
    // 有参构造函数  
    Ellipse(const Point& center, double xR, double yR) : p(center), xRadius(xR), yRadius(yR) {}  

    // 成员函数，输出圆心和轴  
    void draw() const {  
        cout << "Drawing an ellipse: Center(" << p.getX() << ", " << p.getY() << "), x-axis(" << xRadius << "), y-axis(" << yRadius << ")" << endl;  
    }  
};  

// 定义Rectangle类  
class Rectangle {  
private:  
    Point p;      // 左上角坐标  
    double width;  // 矩形宽度  
    double height; // 矩形高度  

public:  
    // 有参构造函数  
    Rectangle(const Point& topLeft, double w, double h) : p(topLeft), width(w), height(h) {}  

    // 成员函数，输出左上角坐标和宽度、高度  
    void draw() const {  
        cout << "Drawing a rectangle: Upper left corner coordinates(" << p.getX() << ", " << p.getY() << "), width(" << width << "), height(" << height << ")" << endl;  
    }  
};  

// 定义Mix类  
class Mix : public Arc, public Circle, public Ellipse, public Rectangle {  
public:  
    // 有参构造函数  
    Mix(const Point& center, double arcRadius, double circleRadius, double xR = 100, double yR = 70, double rectWidth = 100, double rectHeight = 70)   
        : Arc(center, arcRadius),   
          Circle(center, circleRadius),   
          Ellipse(center, xR, yR),   
          Rectangle(center, rectWidth, rectHeight) {}  

    // 成员函数，绘制各个形状  
    void draw() const {  
        Arc::draw();       // 调用Arc的draw  
        Circle::draw();    // 调用Circle的draw  
        Ellipse::draw();   // 调用Ellipse的draw  
        Rectangle::draw();  // 调用Rectangle的draw  
    }  
};  

int main() {
    Point p(320, 240);
    Mix mix(p, 100, 70);
    mix.draw();
    return 0;
}

5.

【描述】
按要求计算数值。
【输入】
第一行是整数n，表示第二行有n个整数。
第二行：n个整数。
所有整数都在0和100之间。
【输出】
先输出：
1
100
101
101
对于输入中第二行的每个整数x，输出两行：
第一行：k=x；
第二行：x的平方。
【输入示例】

3
3 4 5

【输出示例】

1
100
101
101
k=3
9
k=4
16
k=5
25

#include <iostream>
#include <string>
using namespace std;
class A {
private:
    int n;
public:

/* 请在此处编写相关代码 */
 A(int value) : n(value) {}  

    A& operator++() { // 前缀自增  
        n++;  
        return *this;  
    }  

    A operator++(int) { // 后缀自增  
        A temp = *this;  
        n++;  
        return temp;  
    }  

    A& operator=(int value) { // 赋值操作符重载  
        n = value;  
        return *this;  
    }  

    operator int() const { // 转换运算符，方便在输出时直接用整型打印  
        return n;  
    }  

};
class B {
private:
    static int k;
    static int Square(int n) {
	cout <<  "k=" << k <<endl;
	return n * n;
    }
    friend int main();
};
int B::k;
int main() {
    A a1(1), a2(2);
    cout << a1++ << endl;
    (++a1) = 100;
    cout << a1 << endl;
    cout << ++a1 << endl;
    cout << a1 << endl;
    int n;
    cin >> n;
    while(n --) {
	cin >> B::k;
	A a3(B::k);
	cout << B::Square(a3) << endl;
    }
    return 0;
}

6.【描述】
将输入数据按特定要求原样输出。
【输入】
第一行是整数t，表明一共t组数据。
对每组数据：
第一行是整数n，表示下面一共有n行，0<n<100。
下面的每行，以一个字母开头，然后跟着一个整数，两者用空格分隔。字母只会是'A'或'B'。整数范围0到100。
【输出】
对每组输入数据，将其原样输出，每组数据的最后输出一行"****"。
【输入示例】

2
4
A 3
B 4
A 5
B 6
3
A 4
A 3
A 2

【输出示例】

4
A 3
B 4
A 5
B 6
****
3
A 4
A 3
A 2
****

#include <iostream>
using namespace std;

class A {
public:
    int value;
    A(int v) : value(v) {}
};

class B {
public:
    int value;
    B(int v) : value(v) {}
};

// 定义一个指针数组，用于存储 A 和 B 对象
void* a[100];

void PrintInfo(void* obj) {
    // 判断对象的实际类型并输出
    if (A* aObj = static_cast<A*>(obj)) {
        cout << "A " << aObj->value << endl;
    } else if (B* bObj = static_cast<B*>(obj)) {
        cout << "B " << bObj->value << endl;
    }
}

int main() {
    int t;
    cin >> t;
    while(t--) {
	int n;
	cin >> n;
	for(int i = 0; i < n; ++i) {
	    char c;
	    int k;
	    cin >> c >> k;
		if(c == 'A')
		    a[i] = new A(k);
		else
		    a[i] = new B(k);
	}	
	cout << n << endl; 
	for(int i = 0; i < n; ++i)	
	    PrintInfo(a[i]);
	cout << "****" << endl;
    }
}

7.【描述】
下面是类A的定义，需要补充或增加完整的无参构造函数、虚析构函数以及fun()虚函数。class A {

public:
   // ...
   void g() {
      fun();
   }
};

构造函数输出：A constructor，并调用g()函数
析构函数输出：A destructor
fun()函数输出：Call class A's fun
下面是类B的定义，继承类A，需要补充或增加完整的无参构造函数、析构函数。

class B {
public:
    // ...
};

无参构造函数输出：B constructor
析构函数输出：B destructor
下面是类C的定义，继承类B，需要补充或增加完整的无参构造函数、析构函数以及fun()函数。

class C {
public:
    // ...
};

无参构造函数输出：C constructor
析构函数输出：C destructor
fun()函数输出：Call class C's fun
给定如下main函数：

int main() { 
    A *a = new C;
    a->g();
    delete a;
    return 0;
}

【输入】
没有输入。
【输出】
主函数的输出已经写好。

#include <iostream>
using namespace std;

/* 请在此处编写A、B、C类 */
class A {  
public:  
    // 无参构造函数  
    A() {  
        cout << "A constructor" << endl;  
        g();  
    }  

    // 虚析构函数  
    virtual ~A() {  
        cout << "A destructor" << endl;  
    }  

    // 虚函数定义  
    virtual void fun() {  
        cout << "Call class A's fun" << endl;  
    }  

    void g() {  
        fun();  
    }  
};  

class B : public A {  
public:  
    // 无参构造函数  
    B() {  
        cout << "B constructor" << endl;  
    }  

    // 析构函数  
    ~B() {  
        cout << "B destructor" << endl;  
    }  
};  

class C : public B {  
public:  
    // 无参构造函数  
    C() {  
        cout << "C constructor" << endl;  
    }  

    // 析构函数  
    ~C() {  
        cout << "C destructor" << endl;  
    }  

    // 重写虚函数  
    void fun() override {  
        cout << "Call class C's fun" << endl;  
    }  
}; 

int main() {  
    A *a = new C;
    a->g();
    delete a;
    return 0;
}

8.【描述】
下面是不完整的类定义:

class A {
public:
    virtual void print(){
        cout << "print come form class A" << endl;
    }
};
class B : public A {
private:
    char *buf;
public:
    void print() {
        cout << "print come from class B" << endl;
    }   
};
void fun(A *a) {
    delete a;
}

试完成其定义（需要增加必要的构造函数、析构函数）。

类A析构函数输出：A::~A() called

类B析构函数输出：B::~B() called

给定如下main函数：

int main() {
    A *a = new B(10);
    a->print();
    fun(a);
    B *b = new B(20);
    fun(b);
    return 0;
}

【输入】
没有输入。
【输出】
主函数的输出已经写好

#include <iostream>
using namespace std;

/* 请在此处分别编写A、B类 */
class A {  
public:  
    // 构造函数  
    A() {}  

    // 虚析构函数  
    virtual ~A() {  
        cout << "A::~A() called" << endl;  
    }  

    virtual void print() {  
        cout << "print come from class A" << endl;  
    }  
};  

class B : public A {  
private:  
    char *buf;  

public:  
    // 构造函数，接受参数并分配内存  
    B(int size) {  
        buf = new char[size]; // 假设 buf 是用来存储某些数据  
    }  

    // 析构函数  
    ~B() {  
        cout << "B::~B() called" << endl;  
        //delete[] buf; // 释放内存  
    }  

    void print() override {  
        cout << "print come from class B" << endl;  
    }  
};  

void fun(A *a) {
    delete a;
}
int main() {
    A *a = new B(10); 
   a->print();
    fun(a);
    B *b = new B(20);
    fun(b);
    return 0;
}

9.

【描述】
①Shape类是抽象类，包括了纯虚函数getArea（求面积）、getPerimeter（求周长）、show（输出对象信息）以及成员函数getClassName（返回类名“Shape”）。
②Circle类继承了Shape类，包括了double类型的私有数据成员radius，表示圆半径；带默认参数的有参构造函数，radius的默认参数值为1；访问器函数getRadius和更改器函数setRadius；重定义了getArea（求圆面积）、getPerimeter（求圆周长）、show（输出半径）、getClassName（返回类名“Circle”）函数。
③Rectangle继承了Shape类，包括了double类型的私有数据成员width、height，分别表示矩形的宽度和高度；带默认参数的有参构造函数，width和height的默认参数值分别为1、1；访问器函数getWidth、getHeight和更改器函数setWidth、setHeight；重定义了getArea（求矩形面积）、getPerimeter（求矩形周长）、show（输出宽度和高度）、getClassName（返回类名“Rectangle”）函数。
④Triangle类继承了Shape类，包括了double类型的私有数据成员side1、side2和side3，表示三角形三条边；有参构造函数，将三角形三条边设置为给定的参数；重定义了getArea（求三角形面积）、getPerimeter（求三角形周长）、show（输出三条边）、getClassName（返回类名“Triangle”）函数。
假设PI为3.14159。
【输入】
输入圆的半径、矩形的宽度和高度以及三角形的三条边。
【输出】
见【输出示例】
【输入示例】
3.5
5.8 11.8
1 1.5 1
【输出示例】

Circle:
Radius:3.5
Area:38.4845, Perimeter:21.9911
Rectangle:
Width:5.8, Height:11.8
Area:68.44, Perimeter:35.2
Triangle:
Side:1, 1.5, 1
Area:0.496078, Perimeter:3.5

#include <iostream>
#include <string>
#include <cmath>
using namespace std;
const double PI = 3.14159;

/* 请在此处编写Shape、Circle、Rectangle和Triangle类 */
class Shape {  
public:  
    virtual double getArea() const = 0; // 纯虚函数，计算面积  
    virtual double getPerimeter() const = 0; // 纯虚函数，计算周长  
    virtual void show() const = 0; // 纯虚函数，显示信息  
    virtual string getClassName() const { return "Shape"; } // 返回类名  
};  

// Circle 类，继承自 Shape  
class Circle : public Shape {  
private:  
    double radius; // 圆的半径  

public:  
    // 带默认参数的构造函数  
    Circle(double r = 1.0) : radius(r) {}  

    double getArea() const override {  
        return PI * radius * radius; // 计算面积  
    }  

    double getPerimeter() const override {  
        return 2 * PI * radius; // 计算周长  
    }  

    void show() const override {  
        cout << "Radius:" << radius << endl; // 显示圆的半径  
    }  

    string getClassName() const override {  
        return "Circle"; // 返回类名  
    }  
};  

// Rectangle 类，继承自 Shape  
class Rectangle : public Shape {  
private:  
    double width; // 矩形的宽度  
    double height; // 矩形的高度  

public:  
    // 带默认参数的构造函数  
    Rectangle(double w = 1.0, double h = 1.0) : width(w), height(h) {}  

    double getArea() const override {  
        return width * height; // 计算面积  
    }  

    double getPerimeter() const override {  
        return 2 * (width + height); // 计算周长  
    }  

    void show() const override {  
        cout << "Width:" << width << ", Height:" << height << endl; // 显示宽度和高度  
    }  

    string getClassName() const override {  
        return "Rectangle"; // 返回类名  
    }  
};  

// Triangle 类，继承自 Shape  
class Triangle : public Shape {  
private:  
    double side1; // 三角形的第一条边  
    double side2; // 三角形的第二条边  
    double side3; // 三角形的第三条边  

public:  
    // 构造函数  
    Triangle(double s1, double s2, double s3) : side1(s1), side2(s2), side3(s3) {}  

    double getArea() const override {  
        double s = getPerimeter() / 2; // 计算半周长  
        // 使用海伦公式计算面积  
        return sqrt(s * (s - side1) * (s - side2) * (s - side3));  
    }  

    double getPerimeter() const override {  
        return side1 + side2 + side3; // 计算周长  
    }  

    void show() const override {  
        cout << "Side:" << side1 << ", " << side2 << ", " << side3 << endl; // 显示三条边  
    }  

    string getClassName() const override {  
        return "Triangle"; // 返回类名  
    }  
};  

int main() {
    double radius, width, height, side1, side2, side3;
    cin >> radius;
    Circle circle(radius);
    cin >> width >> height;
    Rectangle rectangle(width, height);
    cin >> side1 >> side2 >> side3;
    Triangle triangle(side1, side2, side3);
    cout << circle.getClassName() << ":" << endl;
    circle.show();
    cout << "Area:" << circle.getArea();
    cout << ", Perimeter:" << circle.getPerimeter() << endl;
    cout << rectangle.getClassName() << ":" << endl;
    rectangle.show();
    cout << "Area:" << rectangle.getArea();
    cout << ", Perimeter:" << rectangle.getPerimeter() << endl;
    cout << triangle.getClassName() << ":" << endl;
    triangle.show();
    cout << "Area:" << triangle.getArea();
    cout << ", Perimeter:" << triangle.getPerimeter() << endl;
    return 0;
}

10.

【描述】
①Employee类是抽象类。Employee类的派生类有Boss类、CommissionWorker类、PieceWorker类和HourlyWorker类。
②Employee类包括私有数据成员name（姓名，string类型）；有参构造函数，将name设置为给定的参数；访问器函数getName；还有纯虚函数show和earnings。show和earning函数将在每个派生类中实现，因为每个派生类显示的信息不同、计算工资的方法不同。
③Boss类有固定的周工资且不计工作时间。Boss类包括私有数据成员weeklySalary（周工资，double类型）；有参构造函数，将name、weeklySalary设置为给定的参数；更改器函数setWeeklySalary；show函数和earnings函数。
④CommissionWorker类有工资加上销售提成。CommissionWorker类包括私有数据成员salary（工资，double类型）、commission（佣金，double类型）和quantity（销售数量，int类型）；有参构造函数，将name、salary、commission、quantity设置为给定的参数；更改器函数setSalary、setCommission和setQuantity；show函数和earnings函数。
⑤PieceWorker类的工资根据其生产的产品数量而定。PieceWorker类包括私有数据成员wagePerPiece（每件产品工资，double类型）、quantity（生产数量，int类型）；有参构造函数，将name、wagePerPiece、quantity设置为给定的参数；更改器函数setWage、setQuantity；show函数和earnings函数。
⑥HourlyWorker类的工资根据小时计算并有加班工资。HourlyWorker类包括私有数据成员wage（小时工资，double类型）、hours（工作时数，double类型）；有参构造函数，将name、wage、hours设置为给定的参数；更改器函数setWage、setHours；show函数和earnings函数。
动态绑定show和earnings函数显示和计算各类人员的信息和工资。
【输入】
输入Boss的姓名和周工资。
输入CommissonWorker的姓名、工资、佣金和销售数量。
输入PieceWorker的姓名、每件产品工资和生产数量。
输入HourlyWorker的姓名、小时工资、工作时数。
【输出】
见【输出示例】
【输入示例】

ZhangSan 800.0
LiSi 400.0 3.0 150
WangWu 2.5 200
LiuLiu 13.75 40

【输出示例】

Boss: ZhangSan
Earned: $800
Commission Worker: LiSi
Earned: $850
Piece Worker: WangWu
Earned: $500
Hourly Worker: LiuLiu
Earned: $550

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

/* 请在此处分别编写Employee、Boss、CommissionWorker、PieceWorker、HourlyWorker类 */
class Employee {  
private:  
    string name; // 姓名  

public:  
    // 构造函数  
    Employee(string n) : name(n) {}  
    
    // 访问函数  
    string getName() const {  
        return name;  
    }  

    // 纯虚函数  
    virtual void show() const = 0;  
    virtual double earnings() const = 0;  
};  

// Boss 类，继承 Employee  
class Boss : public Employee {  
private:  
    double weeklySalary; // 周工资  

public:  
    // 构造函数  
    Boss(string n, double salary) : Employee(n), weeklySalary(salary) {}  

    // 设置周工资  
    void setWeeklySalary(double salary) {  
        weeklySalary = salary;  
    }  

    // 显示 Boss 信息  
    void show() const override {  
        cout << "Boss: " << getName() << endl;  
    }  

    // 计算 Boss 收入  
    double earnings() const override {  
        return weeklySalary;  
    }  
};  

// CommissionWorker 类，继承 Employee  
class CommissionWorker : public Employee {  
private:  
    double salary;      // 固定工资  
    double commission;  // 佣金  
    int quantity;       // 销售数量  

public:  
    // 构造函数  
    CommissionWorker(string n, double sal, double com, int qty)  
        : Employee(n), salary(sal), commission(com), quantity(qty) {}  

    // 设置工资  
    void setSalary(double sal) {  
        salary = sal;  
    }  
    
    // 设置佣金  
    void setCommission(double com) {  
        commission = com;  
    }  
    
    // 设置销售数量  
    void setQuantity(int qty) {  
        quantity = qty;  
    }  

    // 显示佣金工人信息  
    void show() const override {  
        cout << "Commission Worker: " << getName() << endl;  
    }  

    // 计算佣金工人收入  
    double earnings() const override {  
        return salary + (commission * quantity);  
    }  
};  

// PieceWorker 类，继承 Employee  
class PieceWorker : public Employee {  
private:  
    double wagePerPiece; // 每件产品的工资  
    int quantity;        // 生产量  

public:  
    // 构造函数  
    PieceWorker(string n, double wage, int qty)  
        : Employee(n), wagePerPiece(wage), quantity(qty) {}  

    // 设置每件产品的工资  
    void setWage(double wage) {  
        wagePerPiece = wage;  
    }  

    // 设置生产数量  
    void setQuantity(int qty) {  
        quantity = qty;  
    }  

    // 显示计件工人信息  
    void show() const override {  
        cout << "Piece Worker: " << getName() << endl;  
    }  

    // 计算计件工人收入  
    double earnings() const override {  
        return wagePerPiece * quantity;  
    }  
};  

// HourlyWorker 类，继承 Employee  
class HourlyWorker : public Employee {  
private:  
    double wage;   // 每小时工资  
    double hours;  // 工作时数  

public:  
    // 构造函数  
    HourlyWorker(string n, double w, double h)  
        : Employee(n), wage(w), hours(h) {}  

    // 设置每小时工资  
    void setWage(double w) {  
        wage = w;  
    }  

    // 设置工作时数  
    void setHours(double h) {  
        hours = h;  
    }  

    // 显示按小时计工资的工人信息  
    void show() const override {  
        cout << "Hourly Worker: " << getName() << endl;  
    }  

    // 计算按小时计工资工人收入  
    double earnings() const override {  
        if (hours <= 40) {  
            return wage * hours; // 正常工资  
        } else {  
            return wage * 40 + (wage * 1.5 * (hours - 40)); // 加班工资  
        }  
    }  
};  

int main() {
    string name;
    double weeklySalary, salary, commission, quantity, wagePerPiece, wage, hours;
    cin >> name >> weeklySalary;
    Boss b(name, weeklySalary);
    cin >> name >> salary >> commission >> quantity;
    CommissionWorker c(name, salary, commission, quantity);
    cin >> name >> wagePerPiece >> quantity;
    PieceWorker p(name, wagePerPiece, quantity);
    cin >> name >> wage >> hours;
    HourlyWorker h(name, wage, hours);
    Employee *ref;      // 基类指针
    ref = &b;
    ref->show();
    cout << "Earned: $" << ref->earnings() << endl;
    ref = &c;
    ref->show();
    cout << "Earned: $" << ref->earnings() << endl;
    ref = &p;
    ref->show();
    cout << "Earned: $" << ref->earnings() << endl;
    ref = &h;
    ref->show();
    cout << "Earned: $" << ref->earnings() << endl;
    return 0;
}