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

好的，下面是代码实现：

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

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

class Employee : public Role {
private:
    int ID;
    double salary;
public:
    Employee() { }
    Employee(string n, int a, char g, int i, double s) : Role(n, a, g), ID(i), salary(s) { }
    Employee(string n, int a, char g) : Role(n, a, g) { }
    void setID(int i) { ID = i; }
    void setSalary(double s) { salary = s; }
    int getID() { return ID; }
    double getSalary() { return salary; }
    void display() {
        Role::display();
        cout << "ID: " << ID << endl;
        cout << "Salary: " << salary << endl;
    }
};

int main() {
    Role* r = new Employee("Tom", 30, 'M', 1001, 5000.0);
    r->display();
    delete r;

    return 0;
}

输出结果：

Name: Tom
Age: 30
Gender: M
ID: 1001
Salary: 5000

在这个示例中，我们定义了一个基类 Role 和一个派生类 Employee。Employee 类继承了 Role 的所有成员，同时扩展了 ID 和 salary 两个成员。基类 Role 和派生类 Employee 都有两个构造函数，其中 Employee 重载了基类的构造函数，并在其中调用了基类的构造函数以初始化基类的成员。在 Employee 类中，我们也重新定义了 display() 函数，以便它能显示出 Employee 类的数据成员。在 main() 函数中，我们定义了一个基类指针 r，使它指向一个 Employee 对象。当我们调用 r->display() 时，它将调用 Employee 类中的 display() 函数，因为它是虚函数。注意，在 delete r 之后，我们需要释放动态分配的内存。