C++(3)_异质链表

终于考完了万恶的期末考，有时间把落下的blog更一下

异质链表

异质链表means链表内节点类型可以不是同一种。

下面放上课程作业（一个小型的学校信息管理系统）中成员类型定义的.h文件。

其中有一个抽象节点（Node）基类Person类，其它类都在此基础上继承；

故在链表（HeterList）类中，定义链表头指针时，只需要将头指针定义为基类类型即可通过该头指针指向其继承类。

#include <iostream>
#include <string>

using namespace std;

//友元类需要事先声明
class HeterList;

/*
*节点类，各类class的定义
*/
//抽象基类 Person
class Person
{
friend class HeterList;

public:
//构造函数
//Person():_name(""),_sex('M'),_age(0),_IDnumber(""),_next(NULL){}

Person(char *name, char sex, int age, char *IDnumber)
:_sex(sex),_age(age),_next(NULL)
{
strcpy_s(Person::_name, name);
strcpy_s(Person::_IDnumber, IDnumber);
}

//纯虚函数
virtual void addNode() = 0;     //将对象添加进链表，变成一个节点
virtual void display() = 0;     //显示信息

//析构函数
~Person() {}

//希望与派生类分享，但不想被其他公共访问的成员
protected:
char _name[20];
char _sex;
int _age;
char _IDnumber[20];

static Person *_ptr;    //定义一个指向Person类对象的静态指针
Person *_next;          //指向下一个节点的指针
};

//教师类
class Teacher:public Person
{
friend class HeterList;

public:
//构造函数
//Teacher():Person(),_fund(0),_major(""),_salary(0){}

Teacher(char *name, char sex, int age, char *IDnumber, int fund, char *major, int salary)
:Person(name, sex, age, IDnumber),_fund(fund),_salary(salary)
{
strcpy_s(Teacher::_major, major);
}

//重写将对象添加进链表函数
void addNode()
{
_ptr = new Teacher(_name, _sex, _age, _IDnumber, _fund, _major, _salary);
}

//重写信息显示函数
void display()
{
cout<<"Name："<<_name<<endl;
cout<<"Sex："<<_sex<<endl;
cout<<"Age:"<<_age<<endl;
cout<<"ID NUmber:"<<_IDnumber<<endl;
cout<<"Job: Teacher"<<endl;
cout<<"Fund:"<<_fund<<endl;
cout<<"Major:"<<_major<<endl;
cout<<"Salary:"<<_salary<<endl;
cout<<endl;
}

//析构函数
~Teacher() {}

private:
int _fund;
char _major[20];
int _salary;
};

//职工类
class Stuff:public Person
{
friend class HeterList;

public:
//构造函数
//Stuff():Person(),_department(""),_position(""),_salary(0){}

Stuff(char *name, char sex, int age, char *IDnumber, char *department, char *position, int salary)
:Person(name, sex, age, IDnumber),_salary(salary)
{
strcpy_s(Stuff::_department, department);
strcpy_s(Stuff::_position, position);
}

void display()
{
cout<<"Name："<<_name<<endl;
cout<<"Sex："<<_sex<<endl;
cout<<"Age:"<<_age<<endl;
cout<<"ID NUmber:"<<_IDnumber<<endl;
cout<<"Job: Stuff"<<endl;
cout<<"Department:"<<_department<<endl;
cout<<"Position:"<<_position<<endl;
cout<<"Salary:"<<_salary<<endl;
cout<<endl;
}

//重写将对象添加进链表函数
void addNode()
{
_ptr = new Stuff(_name, _sex, _age, _IDnumber, _department, _position, _salary);
}

//析构函数
~Stuff() {}

private:
char _department[20];
char _position[20];
int _salary;
};

//本科生类
class Undergraduate:public Person
{
friend class HeterList;

public:
//构造函数
//Undergraduate():Person(),_gradePoint(0){}

Undergraduate(char *name, char sex, int age, char *IDnumber, int gradePoint)
:Person(name, sex, age, IDnumber),_gradePoint(gradePoint){}

void display()
{
cout<<"Name："<<_name<<endl;
cout<<"Sex："<<_sex<<endl;
cout<<"Age:"<<_age<<endl;
cout<<"ID NUmber:"<<_IDnumber<<endl;
cout<<"Job: Undergraduate"<<endl;
cout<<"GradePoint:"<<_gradePoint<<endl;
cout<<endl;
}

//重写将对象添加进链表函数
void addNode()
{
_ptr = new Undergraduate(_name, _sex, _age, _IDnumber, _gradePoint);
}

//析构函数
~Undergraduate() {}

//希望与派生类分享，但不想被其他公共访问的成员
protected:
int _gradePoint;
};

//全日制研究生类
class FulltimePostgraduate:public Undergraduate
{
friend class HeterList;
//friend class Teacher;

public:
//构造函数
//FulltimePostgraduate():Undergraduate(),_major(""),_tutor(""){}

FulltimePostgraduate(char *name, char sex, int age, char *IDnumber, int gradePoint, char *major, char *tutor)
:Undergraduate(name, sex, age, IDnumber, gradePoint)
{
strcpy_s(FulltimePostgraduate::_major, major);
strcpy_s(FulltimePostgraduate::_tutor, tutor);
}

void display()
{
cout<<"Name："<<_name<<endl;
cout<<"Sex："<<_sex<<endl;
cout<<"Age:"<<_age<<endl;
cout<<"ID NUmber:"<<_IDnumber<<endl;
cout<<"Job: FulltimePostgraduate"<<endl;
cout<<"GradePoint:"<<_gradePoint<<endl;
cout<<"Major:"<<_major<<endl;
cout<<"Tutor:"<<_tutor<<endl;
cout<<endl;
}

//重写将对象添加进链表函数
void addNode()
{
_ptr = new FulltimePostgraduate(_name, _sex, _age, _IDnumber, _gradePoint, _major, _tutor);
}

//析构函数
~FulltimePostgraduate() {}

//希望与派生类分享，但不想被其他公共访问的成员
protected:
char _major[20];
char _tutor[20];
};

//在职研究生类
class OnthejobPostgraduate:public FulltimePostgraduate
{
friend class HeterList;

public:
//构造函数
//OnthejobPostgraduate():FulltimePostgraduate(),_salary(0){}

OnthejobPostgraduate(char *name, char sex, int age, char *IDnumber, int gradePoint, char *major, char *tutor, int salary)
:FulltimePostgraduate(name, sex, age, IDnumber, gradePoint, major, tutor),_salary(salary){}

void display()
{
cout<<"Name："<<_name<<endl;
cout<<"Sex："<<_sex<<endl;
cout<<"Age:"<<_age<<endl;
cout<<"ID NUmber:"<<_IDnumber<<endl;
cout<<"Job: FulltimePostgraduate"<<endl;
cout<<"GradePoint:"<<_gradePoint<<endl;
cout<<"Major:"<<_major<<endl;
cout<<"Tutor:"<<_tutor<<endl;
cout<<"Salary:"<<_salary<<endl;
cout<<endl;
}

//重写将对象添加进链表函数
void addNode()
{
_ptr = new OnthejobPostgraduate(_name, _sex, _age, _IDnumber, _gradePoint, _major, _tutor, _salary);
}

//析构函数
~OnthejobPostgraduate() {}

//希望与派生类分享，但不想被其他公共访问的成员
protected:
int _salary;
};

//异质链表类
class HeterList
{
public:
//构造函数
HeterList():Root(NULL){}

void InsertNode(Person *node);  //以基类指针为参数，可以接收所有派生类对象的指针
void SearchNode(char *name);
void DeleteNode(char *name);
void UpdateNode(char *name);
void displayList(); //待改

//析构函数
~HeterList() {}

private:
Person *Root;   //定义链表头指针
};

void HeterList::InsertNode(Person *node)
{
//定义两个查找指针
Person *curr = Root;    //指向当前节点的指针,从Root开始
Person *prev = NULL;    //指向前一个节点的指针

//移到链表的最后一个节点
//如果当前链表没有节点，则curr=Root=NULL
while( curr != NULL )
{
//往后一个节点
prev = curr;
curr = curr->_next;
}

node->addNode();//有了指向当前对象的指针ptr
node->_ptr->_next = curr; //插在最后一个前面
if(prev==NULL)  //当前链表没有节点
{
Root = node->_ptr;
}
else
{
prev->_next = node->_ptr;
}

}

void HeterList::SearchNode(char *name)
{
Person *curr = Root;    //指向当前节点的指针，指向根节点

while( (curr!=NULL) && (strcmp(curr->_name, name) !=0) )
{//找到了跳出，或者到头了跳出
curr = curr->_next;
}
if( curr == NULL )
{//没找到
cout<<"Can't find this member, please check it again!"<<endl;
}
else
{
curr->display();
}
}

void HeterList::DeleteNode(char *name)
{
Person *curr = Root;    //指向当前节点的指针，指向根节点
Person *prev = NULL;    //指向前一个节点的指针

while( (curr!=NULL) && (strcmp(curr->_name, name) !=0) )
{//找到了跳出，或者到头了跳出
prev = curr;
curr = curr->_next;
}
if( (prev==NULL) && (curr!=NULL) )
{//curr指向的第一个就是，把Root移动
Root = curr->_next;
delete curr;
}
else if( (prev!=NULL) && (curr!=NULL) )
{//不是第一个
prev->_next = curr->_next;
delete curr;
}
}

void HeterList::UpdateNode(char *name)
{
Person *curr = Root;    //指向当前节点的指针，指向根节点
Person *prev = NULL;    //指向前一个节点的指针

while( (curr!=NULL) && (strcmp(curr->_name, name) !=0) )
{//找到了跳出，或者到头了跳出
prev = curr;
curr = curr->_next;
}
if( curr == NULL )
{//没找到
cout<<"Can't find this member, please check it again!"<<endl;
}
else
{//找到了

}
}

void HeterList::displayList()
{
Person *curr = Root;
while(curr != NULL)
{
curr->display();
curr = curr->_next;
}
}