定义指向Person::display() 函数的指针，并在main()中通过函数指针的方式调用此函数，

可以这样定义指向Person::display()函数的指针：

void (Person::*displayPtr)() = &Person::display;

这里使用了类成员函数指针的语法格式，其中`void`表示函数返回值类型，`Person::*`表示指向Person类的成员函数，`displayPtr`为指针名称。

然后在main()中，可以通过函数指针的方式调用此函数，示例代码如下：

int main()
{
    Person p("Tom", 18);
    void (Person::*displayPtr)() = &Person::display;
    (p.*displayPtr)(); // 通过函数指针调用Person::display()函数
    return 0;
}

这里先创建一个Person对象p，然后定义一个指向Person::display()函数的指针`displayPtr`，最后通过`(p.*displayPtr)()`的方式调用该函数。注意，调用成员函数时要使用对象名和指针名的组合，中间需要加上`.`或`->`，这里使用`.`来访问成员函数。

相关问题

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

代码如下：

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

class Person {
protected:
    string name;
    int age;
    char gender;
public:
    // 默认构造函数
    Person() {}
    // 带参数的构造函数
    Person(string name, int age, char gender): name(name), age(age), gender(gender) {}
    // 姓名的读写函数
    void setName(string name) {
        this->name = name;
    }
    string getName() {
        return name;
    }
    // 年龄的读写函数
    void setAge(int age) {
        this->age = age;
    }
    int getAge() {
        return age;
    }
    // 性别的读写函数
    void setGender(char gender) {
        this->gender = gender;
    }
    char getGender() {
        return gender;
    }
    // 虚函数display()
    virtual void display() {
        cout << "Name: " << name << endl;
        cout << "Age: " << age << endl;
        cout << "Gender: " << gender << endl;
    }
};

class Role : public Person {
protected:
    string title;
    string department;
public:
    // 默认构造函数
    Role() {}
    // 带参数的构造函数
    Role(string name, int age, char gender, string title, string department) : 
        Person(name, age, gender), title(title), department(department) {}
    // 职位的读写函数
    void setTitle(string title) {
        this->title = title;
    }
    string getTitle() {
        return title;
    }
    // 部门的读写函数
    void setDepartment(string department) {
        this->department = department;
    }
    string getDepartment() {
        return department;
    }
    // 虚函数display()
    virtual void display() {
        Person::display();
        cout << "Title: " << title << endl;
        cout << "Department: " << department << endl;
    }
};

class Employee : public Role {
private:
    int ID;
    float salary;
public:
    // 默认构造函数
    Employee() {}
    // 带参数的构造函数
    Employee(string name, int age, char gender, string title, string department, int ID, float salary) :
        Role(name, age, gender, title, department), ID(ID), salary(salary) {}
    // ID的读写函数
    void setID(int ID) {
        this->ID = ID;
    }
    int getID() {
        return ID;
    }
    // 薪资的读写函数
    void setSalary(float salary) {
        this->salary = salary;
    }
    float getSalary() {
        return salary;
    }
    // 重新定义虚函数display()
    virtual void display() {
        Role::display();
        cout << "ID: " << ID << endl;
        cout << "Salary: " << salary << endl;
    }
};

int main() {
    Employee emp("Tom", 25, 'M', "Manager", "Sales", 12345, 5000.0);
    Person* p = &emp;
    p->display();
    return 0;
}

这个程序定义了一个 `Person` 基类，一个 `Role` 派生类以及一个 `Employee` 派生类。`Person` 类定义了姓名、年龄、性别三个数据成员，以及对应的读写函数 `getXXX()` 和 `setXXX()`，还有一个虚函数 `display()`。`Role` 类继承了 `Person` 类，并添加了职位和部门两个数据成员，同时也有一个虚函数 `display()`。`Employee` 类继承了 `Role` 类，并添加了职工编号和薪资两个数据成员，同时也有一个重新定义的虚函数 `display()`。

在主函数中，我们创建了一个 `Employee` 类对象 `emp`，并将其指针赋值给基类指针 `p`，然后调用了 `p->display()` 函数，这里会调用 `Employee` 类中重新定义的 `display()` 函数，输出了 `Employee` 类中所有的数据成员的值。

定义一个人员CPerson类，包含数据成员年龄和姓名，定义一个CPerson类的派生类教师CTeacher类，包含数据成员专业和职称。分别为两个类定义带参数的构造函数初始化，再分别定义display（）函数输出信息。将display()函数定义为虚函数，并用CPerson类的指针分别指向CPerson类和CTeacher类的对象，实现多态。编写主函数测试。

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

首先，我们需要定义一个基类 `CPerson`，其中包含 `age` 和 `name` 两个数据成员。同时，我们需要定义一个带参数的构造函数来初始化这两个数据成员。

class CPerson {
public:
    CPerson(int age, std::string name) : age(age), name(name) {}

    virtual void display() {
        std::cout << "Age: " << age << ", Name: " << name << std::endl;
    }

protected:
    int age;
    std::string name;
};

接下来，我们定义一个 `CTeacher` 类，它是 `CPerson` 的派生类。除了继承 `CPerson` 的数据成员外，它还包含了 `major` 和 `title` 两个数据成员。同样，我们需要定义一个带参数的构造函数来初始化这两个数据成员。

class CTeacher : public CPerson {
public:
    CTeacher(int age, std::string name, std::string major, std::string title)
            : CPerson(age, name), major(major), title(title) {}

    void display() override {
        std::cout << "Age: " << age << ", Name: " << name
                  << ", Major: " << major << ", Title: " << title << std::endl;
    }

private:
    std::string major;
    std::string title;
};

注意，我们将 `CPerson` 中的 `display()` 函数定义为了虚函数，并在 `CTeacher` 中进行了重写。

最后，我们在主函数中创建一个 `CPerson` 类的对象和一个 `CTeacher` 类的对象，并用 `CPerson` 类的指针分别指向它们，并分别调用 `display()` 函数，实现多态。

int main() {
    CPerson person(20, "Tom");
    CTeacher teacher(30, "Jack", "Computer Science", "Professor");

    CPerson* p1 = &person;
    CPerson* p2 = &teacher;

    p1->display();
    p2->display();

    return 0;
}

输出结果为：

Age: 20, Name: Tom
Age: 30, Name: Jack, Major: Computer Science, Title: Professor

这就完成了我们的需求，同时也实现了多态的效果。