2. 实现 Teacher 教师类。 2.1 包含私有变量 姓名 name，基本工资 salary 数据成员。 2.2 实现无参的构造函数对 name 和 salary 进行初始化，默认分别为 wumingshi 和 5000。 2.3 实现带 2 个参数的构造函数对 name 和 salary 进行初始化。 2.4 实现获取基本工资的 getSalary 成员函数，得到对象的 salary 值。 2.5 实现显示 show 函数，输出 name 和 salary，

以下是Teacher类的实现：

#include <iostream>
#include <string>

class Teacher {
private:
    std::string name;
    int salary;
public:
    Teacher(): name("wumingshi"), salary(5000) {}

    Teacher(std::string n, int s): name(n), salary(s) {}

    int getSalary() const {
        return salary;
    }

    void show() const {
        std::cout << "Name: " << name << ", Salary: " << salary << std::endl;
    }
};

在上面的代码中，我们定义了一个名为 Teacher 的类，它有两个私有成员变量：姓名（name）和基本工资（salary）。我们实现了一个默认构造函数和一个带有两个参数的构造函数，用于初始化这两个成员变量。我们还实现了一个名为 getSalary 的公共成员函数，用于获取对象的 salary 值。最后，我们实现了一个名为 show 的公共成员函数，用于输出对象的姓名和基本工资。

相关问题

3. 通过继承 Teacher 类的方式，实现 Professor 教授类。 3.1 包含私有的类成员变量 birth（是 Birthday 类对象，代表出生日期），私有变量 *revenue（动态数组，代表收入），私有变量 typeNum（代表收入种类的数量，即 revenue 长度）。 3.2 实现构造函数分别对基类和派生类成员进行初始化，即对 name, salary, birth, *revenue, typeNum 进行初始化。 3.3 实现拷贝构造函数（深拷贝）。

以下是实现 Professor 类的代码：

#include <iostream>
#include <cstring>

using namespace std;

class Birthday {
private:
    int year;
    int month;
    int day;
public:
    Birthday(int y, int m, int d) : year(y), month(m), day(d) {}
    void print() {
        cout << year << "-" << month << "-" << day << endl;
    }
};

class Teacher {
protected:
    char *name;
    double salary;
public:
    Teacher(const char *n, double s) {
        name = new char[strlen(n) + 1];
        strcpy(name, n);
        salary = s;
    }
    virtual ~Teacher() {
        delete[] name;
    }
    virtual void print() {
        cout << "Name: " << name << ", Salary: " << salary << endl;
    }
};

class Professor : public Teacher {
private:
    Birthday birth;
    double *revenue;
    int typeNum;
public:
    Professor(const char *n, double s, int y, int m, int d, double *r, int t) : Teacher(n, s), birth(y, m, d), typeNum(t) {
        revenue = new double[typeNum];
        for (int i = 0; i < typeNum; i++) {
            revenue[i] = r[i];
        }
    }
    Professor(const Professor &p) : Teacher(p), birth(p.birth), typeNum(p.typeNum) {
        revenue = new double[typeNum];
        for (int i = 0; i < typeNum; i++) {
            revenue[i] = p.revenue[i];
        }
    }
    ~Professor() {
        delete[] revenue;
    }
    void print() {
        cout << "Name: " << name << ", Salary: " << salary << endl;
        cout << "Birth: ";
        birth.print();
        cout << "Revenue: ";
        for (int i = 0; i < typeNum; i++) {
            cout << revenue[i] << " ";
        }
        cout << endl;
    }
};

int main() {
    double revenue[2] = { 10000, 20000 };
    Professor p("John", 50000, 1980, 1, 1, revenue, 2);
    p.print();

    Professor p2 = p;
    p2.print();

    return 0;
}

在上述代码中，我们定义了一个 Birthday 类，用于表示教授的出生日期。在 Professor 类中，我们增加了私有成员变量 birth、revenue 和 typeNum，并在构造函数中对其进行初始化。其中，birth 是 Birthday 类对象，revenue 是一个动态数组，typeNum 表示 revenue 的长度。

在实现拷贝构造函数时，我们采用了深拷贝的方式，将教授对象的所有成员变量都复制到新对象中。需要注意的是，在拷贝构造函数中也需要对基类进行复制。同时，我们也需要在析构函数中删除动态数组 revenue。

最后，在 main 函数中，我们创建了一个 Professor 对象 p，并对其进行了输出。接着，我们创建了另一个 Professor 对象 p2，并将其初始化为 p 的拷贝，再次对其进行输出。

使用C++解决问题，并在解决后给出详细解题思路: 现有一个基类（class Base）包括name、sex两个数据成员和一个getdata( )成员函数，编程实现以下要求 从基类中派生出一个教师类，增加salary（工资）数据成员和用于输入数据的get2( )、用于输出三个数据成员的display2( )。 为派生类添加有参构造函数。请编程验证。

解题思路：

1. 首先需要定义一个基类Base，包括name、sex两个数据成员和一个getdata( )成员函数。

2. 接着需要从基类中派生出一个教师类，增加salary（工资）数据成员和用于输入数据的get2( )、用于输出三个数据成员的display2( )。

3. 为派生类添加有参构造函数。

4. 最后在主函数中验证该程序的正确性。

下面是完整的C++代码实现：

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

class Base {
public:
    string name;
    char sex;
    void getdata() {
        cout << "Please enter the name: ";
        cin >> name;
        cout << "Please enter the sex: ";
        cin >> sex;
    }
};

class Teacher : public Base {
public:
    int salary;
    void get2() {
        getdata();
        cout << "Please enter the salary: ";
        cin >> salary;
    }
    void display2() {
        cout << "Name: " << name << endl;
        cout << "Sex: " << sex << endl;
        cout << "Salary: " << salary << endl;
    }
    Teacher(string n, char s, int sal) {
        name = n;
        sex = s;
        salary = sal;
    }
};

int main() {
    Teacher t("Tom", 'M', 5000);
    t.display2();
    return 0;
}

在上述代码中，我们首先定义了一个基类Base，其中包含了name、sex两个数据成员和一个getdata()成员函数。

然后，我们从基类中派生出一个教师类Teacher，增加了一个salary（工资）数据成员和用于输入数据的get2()、用于输出三个数据成员的display2()。为了验证程序的正确性，我们还为派生类添加了一个有参构造函数。

最后，在主函数中，我们创建了一个Teacher对象t，并通过构造函数将其初始化为Tom、M、5000。然后，调用display2()函数输出t的三个数据成员。