作业_纯虚函数的应用_继承_单向链表_员工信息

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

class Object {                 //抽象结点数据类,用于派生实际结点数据类
public :
    Object() {                 //可省略---因为有默认构造函数，且正好它什么都不做 
    } 
    virtual int IsEqual(Object &) = 0;     //实现两个结点数据的比较
    virtual float Data() = 0;                //得到实际结点数据类的数据 
    virtual void Show() = 0;               //输出一个结点上的数据 
    virtual ~Object() {}                   //虚析函数 
};

class Node {                   //结点类
    Object *Info;              //指向结点的数据域
    Node *Next;                //指向下一个结点
public :
    Node() {
        Info = nullptr; Next = nullptr;      //默认构造函数 
    } 
    Node(Node &node) {
        Info = node.Info; Next = node.Next;  //复制构造函数 
    }
    void FillInfo(Object *obj) {             //使Info指向数据域,实参为实际结点数据类, 
        Info = obj; 
    }
    friend class List;                       //声明友元类 
};

//定义单向链表类 
class List {               
    Node *Head;             //链表首指针
public : 
    List() {
        Head = nullptr; 
    }
    ~List() {               //析构函数 
        DeleteList();
    }
    void AddNode(Node *node);       //插入链表
    Node* Insert(Node *node);         //升序链表
    Node* LookUp(Object &obj);      //查找链表
    Node* DeleteNode(Node *node);     //删除指定链表
    void ShowList();                //输出整条链表
    void DeleteList();              //删除整条链表 
};

void List::AddNode(Node *node)      //有序添加结点--调用Insert函数 
{
    if (Head == nullptr)           
    {
        Head = node; node->Next = nullptr;    
    }    
    else 
    {
        node = Insert(node);
    }
} 

Node* List::Insert (Node *node)
{
    if (node->Info->Data() < Head->Info->Data())
    {
        node->Next = Head; Head = node;
        return node;
    }
    Node *p1, *p2;
    p2 = p1 = Head;
    while (p2->Next && p2->Info->Data() < node->Info->Data())
    {
        p1 = p2; p2 = p2->Next;
    }
    if (node->Info->Data() > p2->Info->Data())
    {
        p2->Next = node;  node->Next = nullptr;
    }
    else
    {
        p1->Next = node; node->Next = p2;
    }
    return Head;
}

Node* List::DeleteNode(Node *node)
{
    if (node == Head)
        Head = Head->Next;
    else
    {
        Node *p1, *p2;
        p2 = p1 = Head;
        while (p2->Next && p2 != node)
        {
            p1 = p2; p2 = p2->Next;
        }
        if (p2 == node) 
            p1->Next = p2->Next;
    }
    return node;
}

Node* List::LookUp(Object &obj)
{
    Node *p = Head;
    while (p)
    {
        if (p->Info->IsEqual(obj)) return p;
        p = p->Next;
    }
    return nullptr;
}

void List::ShowList()
{
    Node *p = Head;
    while (p)
    {
        p->Info->Show();  p = p->Next;
    }
}

void List::DeleteList()
{
    Node *p;
    while (Head)
    {
        p = Head; 
        delete p->Info;     //delete Object类类型的指针时 调用的是指针指向的派生类的析构函数 
        Head = p->Next;
        delete p;
    }
}
//员工类 
class Staff : public Object{             //实际结点数据类:由抽象类Object类派生出 
    char *Name;
    string Address;
    float Salary;
public :
    Staff(char *name = "",string address = "",float salary = 0.0f) {
        Name = new char[strlen(name)+1];
        strcpy(Name,name); 
        Address = address;
        Salary = salary;
    }
    void SetData(char *name = "",string address = "",float salary = 0.0f) {
        Name = new char[strlen(name)+1];
        strcpy(Name,name); 
        Address = address;
        Salary = salary;
    }
    virtual float Data() {
        return Salary;
    }
    int IsEqual(Object &obj)
    {
        Staff t = (Staff&) obj;
        return Salary == t.Salary;
    }
    void Show() 
    {
        cout << "姓名: " << Name << ",地址: " << Address << ",工资: " << Salary << endl;  
    }
    ~Staff() {
        delete []Name;
    }
}; 

int main(void)
{
    int n;
    char name[9];
    string address;
    float salary;
    Staff *p;
    Node *pn, *pt;
    List list;
    
    cout << "input the num of staff : ";
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        pn = new Node;
        cout << "输入姓名、地址、工资: "; 
        cin >> name >> address >> salary;
//        p.SetData(name,address,salary);    
        p = new Staff(name,address,salary);
        pn->FillInfo(p);
        list.AddNode(pn); 
    }
    list.ShowList();             //显示当前链表数据 
    cout << endl;
//    pn = list.LookUp(*p);
    Staff da;                    //声明派生类类型对象 
    cout << "输入新增成员的薪水(新成员已经确定): ";
    cin >> salary;               
    da.SetData("sandy","美国",salary); //修改派生类对象的数据 
    pn = new Node;
    pn->FillInfo(&da);           //将结点数据指针指向派生的数据---检测fillinfo是否会指向Staff类普通对象
    list.AddNode(pn);            //将新结点(升序)添加到链表中 
    list.ShowList();            
    cout << endl;
    
    if (pn) pn = list.LookUp(da);//在链表中寻找指定数据(派生类对象),找到返回该结点,否则返回NULL 
    if (pn) 
        pt = list.DeleteNode(pn);//删除指定的链表---返回值为该结点 
    list.ShowList();
    cout << endl;
    list.DeleteList();
    return 0;

}