帮我编写一个C++程序
//朋友，你好，以下的程序你再简单修改一下就行了，注释的非常明白了
题目：
大学中的人员分三类 ：学生，教师和职员，他们的基本信息如下：
学生：姓名，年龄，学号，年级，成绩
教师：姓名，年龄，身份证号，职称，工资
职员：姓名，年龄，身份证号，工资
现在需要管理各类人员的信息，请用面向对象的方法设计一个异质链表，用来存放他们的信息。
/*异质链表实现：有三个类 student，teacher，staff，再定义一个
链表类，此类用来存放这几个不同类的对象，并将链表类 list 声明为所有这些
类的友元，使它们可以访问它们的私有成员。*/
#include <iostream.h>
#include <string.h>
#include <conio.h>
class person{ //定义一个***同的基类，它具有公***的数据成员
friend class list; //链表类作为本类的友元
protected:
char name[20]; //定义姓名
int age; //定义年龄
char add[40]; //定义地址
char tele[20]; //定义电话号码
static person *ptr; //定义一个指向person类对象的静态指针
person *next; //指向下一个对象的指针
public:
person(char *name,int age,char *add,char *tele);//构造函数
virtual void print(); //说明虚函数
virtual void insert(){};//定义虚函数并且什么也不做，只定义一个接口
};
class student:public person{ //派生类 student
friend class list; //链表类作为本类的友元
int level; //定义年级
float grade_point_average; //定义平均分
public:
student(char *name,int age,char *add,char *tele, int level,
float grade_point_average); //声明构造函数
void print(); //重新定义print()函数
void insert(); //重新定义insert()函数
};
//
class teacher:public person{ //派生类 teacher
friend class list; //链表类作为本类的友元
float salary; //定义工资
public:
teacher(char *name,int age,char *add,char *tele,float salary);
//声明构造函数
void print(); //重新定义print()函数
void insert(); //重新定义insert()函数
};
//
class staff:public person{ //派生类 staff
friend class list; //链表类作为本类的友元
float hourly_wages; //定义计时工资
public:
staff(char *name,int age,char *add,char *tele,
float hourly_wages); //声明构造函数
void print(); //重新定义print()函数
void insert(); //重新定义insert()函数
};
//
class list{ //定义异质链表类
person *root; //链表头指针
public:
list(){ root=0; } //链表构造函数，初始为 0
void insert_person(person *node); //向链表插入一个对象结点
void remove(char *name); //从链表移去一个对象结点
void print_list(); //输出整个链表
};
//
person::person(char *name,int age,char *add,char *tele)
{ //person 的构造函数
strcpy(person::name,name);
strcpy(person::add,add);
strcpy(person::tele,tele);
person::age=age;
next=0;
}
void person::print() //基类的虚成员函数print()版本，输出基类数据成员
{
cout<<"\nname: "<<name<<"\n";
cout<<"age: "<<age<<"\n";
cout<<"address: "<<add<<"\n";
cout<<"telephone number: "<<tele<<"\n";
}
//
student::student(char *name,int age,char *add,char *tele, int level,
float grade_point_average):person(name,age,add,tele)
{ //student 派生类的构造函数，需缀上基类的构造函数
student::level=level;
student::grade_point_average=grade_point_average;
}
void student::print() //派生类 student的成员函数print()新版本
{
person::print();
cout<<"grade point average: "<<grade_point_average<<"\n";
}
void student::insert()
{ //将 student 类的一个对象赋给 ptr 基类指针，这是允许的
ptr=new student(name,age,add,tele,level,grade_point_average);
}
//
teacher::teacher(char *name,int age,char *add,char *tele, float salary)
:person(name,age,add,tele) //teacher 派生类的构造函数，需缀上
//基类的构造函数
{
teacher::salary=salary;
}
void teacher::print() //派生类 teacher的成员函数print()新版本
{
person::print();
cout<<"salary: "<<salary<<"\n";
}
void teacher::insert()
{ //将 teacher类的一个对象赋给 ptr 基类指针，这是允许的
ptr=new teacher(name,age,add,tele,salary);
}
//
staff::staff(char *name,int age,char *add,char *tele, float hourly_wages)
:person(name,age,add,tele) //staff 派生类的构造函数，需缀上
//基类的构造函数
{
staff::hourly_wages=hourly_wages;
}
void staff::print() //派生类 staff的成员函数print()新版本
{
person::print();
cout<<"hourly_wages: "<<hourly_wages<<"\n";
}
void staff::insert()
{ //将 staff类的一个对象赋给 ptr 基类指针，这是允许的
ptr=new staff(name,age,add,tele,hourly_wages);
}
//
void list::insert_person(person *node)
{ //向异质链表插入一个对象，可能是student或teacher或staff
char key[20];
strcpy(key,node->name); //将需插入的对象的姓名赋给key
person *curr_node=root;
person *previous=0; //定义二个查找指针
while(curr_node !=0 && strcmp(curr_node->name,key)<0)
{ //用 curr_node在前，previous在后及 key 循环查找插入位置，由 name
//字符串升序排序，strcmp(串1,串2)<0 表示串1<串2，继续找
previous=curr_node;
curr_node=curr_node->next;
}
node->insert(); //由于 insert() 是虚函数，它会根据 node 指针的对象调
//用不同的版本：ptr=new <三个派生类名之一>(数据成员变量表)，
//而数据成员变量是由构造函数赋值的，由 new 特性： int *s;
// s=new int(20); 会开辟空间并把值20给空间，因此说：
//调用虚函数将待插入对象赋给 ptr 所指向的单元
node->ptr->next=curr_node;
if(previous==0)
root=node->ptr;
else
previous->next=node->ptr;
//以上三句是把 ptr 指的结点插入链中，这里：node->ptr, previous->ptr,
//curr_node->ptr 统统都是一样的，即相当于 person::ptr 说明 ptr 受限的
//对象是stu::ptr或tea::ptr或sta::ptr，因此 node->ptr->next 可写成
// (node->ptr)->next 或 person::ptr->next 但不能把 node->name 写成
// person::name，它只能出现在构造函数中
}
void list::remove(char *name)
{ //从异质链表中移去一对象，此对象用关键字 name 去匹配
person *curr_node=root;
person *previous=0;
while(curr_node !=0 && strcmp(curr_node->name,name)!=0)
{ //用循环寻找此对象
previous=curr_node;
curr_node=curr_node->next;
}
if(curr_node!=0 && previous==0) //若此对象为链表中的头结点
{
root=curr_node->next;
delete curr_node;
}
else if(curr_node!=0 && previous!=0) //此对象为链表中的非头结点
{
previous->next=curr_node->next;
delete curr_node;
}
}
void list::print_list()
{
person *cur=root; //先将头指针赋给 cur
while(cur!=0) //循环输出结点内容并移动指针
{
cur->print(); //根据 cur 所指向的对象不同调用不同的 print() 版本
cur=cur->next;
}
}
//
person *person::ptr=0; //为静态变量赋初值
int main()
{
char c;
list people; //定义 list 类的对象 people ，同时调用 list 构造函数，
//也即 root=0;
student stu("刘影liuying",20,"上海shanghai","03578395-456",3,80.0);
//定义 student 类的对象 stu，同时调用 student 构造函数，
//也即先基类 person 构造函数，再自己
teacher tea("李明liming",35,"北京beijing","0105918695-106",560.50);
staff sta("陈林chenling",40,"青岛qingdao","05325895944-335",10);
people.insert_person(&stu);
people.insert_person(&tea);
people.insert_person(&sta);
cout<<"插入结束!\n";
people.print_list();
cout<<"\n以上打印出原链表! 打 c <回车> 继续....";
cin>>c;
people.remove("陈林chenling");
people.remove("李明liming");
people.remove("王迢wangchong");
cout<<"删除结束!\n";
people.print_list();
cout<<"\n以上打印出删除后链表!\n";
return 0;
}