用动态联编机制处理学生信息： 1．定义抽象类process：只提供一个纯虚函数print()； 2．定义person类，公有继承process类，定义print()成员函数显示相关信息（用前面已用过的类）； 3．定义student类，公有继承person类，定义print()成员函数显示相关信息（用前面已用过的类）； 4．在main()函数中，定义process指针变量调用person 对象及student对象。 说明：可将process类的定义及person类的定义放在同一个头文件中

好的，下面是实现以上要求的代码：

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

// 定义抽象类process
class process {
public:
    virtual void print() = 0;    // 纯虚函数
};

// 定义person类，公有继承process类
class person : public process {
protected:
    string name;
    int age;
    char gender;
public:
    person(string n, int a, char g) : name(n), age(a), gender(g) {}   // 构造函数
    void print() {    // 实现纯虚函数
        cout << "Name: " << name << endl;
        cout << "Age: " << age << endl;
        cout << "Gender: " << gender << endl;
    }
};

// 定义student类，公有继承person类
class student : public person {
private:
    string school;
    int grade;
public:
    student(string n, int a, char g, string s, int gde) : person(n, a, g), school(s), grade(gde) {}   // 构造函数
    void print() {    // 实现纯虚函数
        person::print();    // 调用父类的print()函数
        cout << "School: " << school << endl;
        cout << "Grade: " << grade << endl;
    }
};

int main() {
    // 定义process指针变量调用person对象及student对象
    process* ptr;
    person p("Tom", 20, 'M');
    student s("Lily", 18, 'F', "ABC High School", 3);

    ptr = &p;    // 指向person对象
    ptr->print();    // 调用person的print()函数

    ptr = &s;    // 指向student对象
    ptr->print();    // 调用student的print()函数

    return 0;
}

运行以上代码，输出结果如下：

Name: Tom
Age: 20
Gender: M
Name: Lily
Age: 18
Gender: F
School: ABC High School
Grade: 3

说明：以上代码实现了动态联编（也称为运行时多态）。通过定义抽象类process和纯虚函数print()，实现了多态性。在main()函数中，定义process指针变量ptr，通过指向不同的对象（person对象和student对象），调用它们的print()函数，实现了动态联编。具体来说，指针变量ptr指向person对象时，调用的是person的print()函数；指针变量ptr指向student对象时，调用的是student的print()函数。这就是动态联编的好处，可以在运行时根据需要动态地选择调用哪个函数。