派生类至少有一个基类吗

是的，派生类至少有一个基类。派生类是从一个或多个基类派生而来的，它继承了其基类的属性和方法，并且可以添加自己的属性和方法。在C++中，可以使用关键字"：public"或"：private"或"：protected"指定派生类和基类之间的访问权限。这些关键字决定了基类中哪些成员可以在派生类中访问，哪些成员不能在派生类中访问。

相关问题

定义一个基类person类类内有数据成员姓名，年龄，性别，有对各数据成员进行读写的函数getXXX()和setXXX()，有一个虚函数display()，该函数显示姓名，年龄，性别等数据成员的值，同时类内至少定义两个构造函数。 从Role类派生出一个“Employee”类，该类具有Role类的所有成员（构造函数除外），并扩展数据成员ID （职工编号）和salary（薪资）。同样要有至少两个构造方法，并重新定义display()函数。 主函数内定义基类指针和派生类对象，并使基类指针指向派生类对象，通过该基类指针访问虚函数display()。

好的，这里是一个符合要求的代码实现：

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def get_name(self):
        return self.name

    def set_name(self, name):
        self.name = name

    def get_age(self):
        return self.age

    def set_age(self, age):
        self.age = age

    def get_gender(self):
        return self.gender

    def set_gender(self, gender):
        self.gender = gender

    def display(self):
        print(f"Name: {self.name}")
        print(f"Age: {self.age}")
        print(f"Gender: {self.gender}")


class Role:
    def __init__(self, role_name):
        self.role_name = role_name

    def display(self):
        print(f"Role: {self.role_name}")


class Employee(Role, Person):
    def __init__(self, name, age, gender, employee_id, salary):
        Person.__init__(self, name, age, gender)
        self.employee_id = employee_id
        self.salary = salary

    def display(self):
        Person.display(self)
        print(f"Employee ID: {self.employee_id}")
        print(f"Salary: {self.salary}")


# 创建一个Employee类的对象
employee = Employee("Tom", 25, "Male", "E001", 5000)

# 创建一个基类指针，指向Employee类的对象
person = employee

# 调用虚函数display()，输出Employee类对象的信息
person.display()

这个代码定义了一个Person类作为基类，包含了姓名、年龄、性别等数据成员，以及对这些数据成员进行读写的函数getXXX()和setXXX()，还有一个虚函数display()，用于显示这些数据成员的值。然后，定义了一个Role类作为Person类的派生类，同时定义了一个Employee类作为Role类的派生类。Employee类添加了两个数据成员：员工编号和薪资，并重新定义了虚函数display()，以便输出这些新的数据成员的值。最后，创建了一个Employee类的对象，通过基类指针调用虚函数display()，输出了Employee类对象的信息。

希望这个代码能够帮到你！

定义一个基类“Role”，类内有数据成员姓名，年龄，性别，有对各数据成员进行读写的函数getXXX()和setXXX()，有一个虚函数display()，该函数显示姓名，年龄，性别等数据成员的值，同时类内至少定义两个构造函数。 从Role类派生出一个“Employee”类，该类具有Role类的所有成员（构造函数除外），并扩展数据成员ID （职工编号）和salary（薪资）。同样要有至少两个构造方法，并重新定义display()函数。 主函数内定义基类指针和派生类对象，并使基类指针指向派生类对象，通过该基类指针访问虚函数display()。

好的，我来为您解答这个问题。

首先，定义一个基类 Role，声明数据成员和成员函数：

class Role {
protected:
    std::string name;
    int age;
    char gender;
public:
    Role() {}
    Role(const std::string& n, int a, char g) : name(n), age(a), gender(g) {}
    virtual void display() const {
        std::cout << "Name: " << name << ", "
                  << "Age: " << age << ", "
                  << "Gender: " << gender << std::endl;
    }
    std::string getName() const { return name; }
    int getAge() const { return age; }
    char getGender() const { return gender; }
    void setName(const std::string& n) { name = n; }
    void setAge(int a) { age = a; }
    void setGender(char g) { gender = g; }
};

接下来，从 Role 类派生出一个 Employee 类，添加新成员 ID 和 salary，并重新定义 display() 函数：

class Employee : public Role {
private:
    int id;
    double salary;
public:
    Employee() {}
    Employee(const std::string& n, int a, char g, int i, double s)
        : Role(n, a, g), id(i), salary(s) {}
    Employee(const Role& r, int i, double s) : Role(r), id(i), salary(s) {}
    void display() const override {
        Role::display();
        std::cout << "ID: " << id << ", "
                  << "Salary: " << salary << std::endl;
    }
};

最后，在主函数中创建基类指针和派生类对象，并使用基类指针调用虚函数 display()：

int main() {
    Role* p = new Employee("Tom", 25, 'M', 1001, 5000.0);
    p->display();
    delete p;
    return 0;
}

输出结果为：

Name: Tom, Age: 25, Gender: M
ID: 1001, Salary: 5000