c++之自定义链表类的创建

参考了网上的一些资料，同时也是主要想参照c#的列表写一个类似的

整个类功能有添加，删除，排序（一共两个，一个是正排序，一个是自定义排序），判定value存不存在，判定是否为空，size显示，打印全部，清空列表，用中括号index取值这几个功能

// test.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include 
#include

using namespace std;
template 
class Node 
{
public:
    Node *next;
    Node *prev;
    T date;
 
};

template 
class List 
{
private:
    Node *head;
    Node *tail;
    int length;

public:
    List();
    List(const List& ln);
    ~List();
    void Add(T e);
    void Sort();
    void Remove(T e);
    bool IsContain(T index);
    bool isEmpty();
    int szie();
    void Show();
    void Clear();
    T operator[](int e);
    void Sort(int(*result)(T, T));
    
};
template
void List::Sort(int(*result)(T e1,T e2))
{   
    if (length <= 1) return;
    Node *p = head->next;
    for (int i = 0; i < length - 1; i++)
    {
        Node *q = p->next;
        for (int j = i + 1; j < length; j++)
        {
            if ((*result)(p->date, q->date) > 0)
            {
                T temp = p->date;
                p->date = q->date;
                q->date = temp;
            }
            else if ((*result)(p->date, q->date) < 0) 
            {
                T temp = q->date;
                q->date = p->date;
                p->date = temp;
            }
            q = q->next;
        }
        p = p->next;
    }
}


template
List::List() 
{
    head = new Node;
    tail = new Node;
    head->next = tail;
    head->prev = nullptr;
    tail->next = nullptr;
    tail->prev = head;
    length = 0;
}

template
List::List(const List &ln) 
{
    head = new Node;
    tail = new Node;
    head->prev = nullptr;   
    head->next = tail;
    tail->prev = head;
    tail->next = nullptr;
    length = 0;
    Node *temp = ln.head;
    while (temp->next != ln.tail)
    {
        temp = temp->next;
        tail->date = temp->date;
        Node *p = new Node;
        p->prev = tail;
        tail->next = p;
        tail = p;
        length++;
    }
    tail->next = nullptr;
}

template
void List::Add(T e) 
{
    Node *temp = this->tail;
    tail->date = e;
    tail->next = new Node;
    Node *p = tail;
    tail = tail->next;
    tail->next = nullptr;
    tail->prev = p;
    length++;
}

template
void List::Remove(T index)
{
    if (length == 0)
    {
        cout << "list is empty";
        return NULL;
    }
    Node *p = head;
    while (p->next != nullptr) 
    {
        p = p->next;
        if (p->date == index) 
        {
            Node *temp = p->prev;
            temp->next = p->next;
            p->next->prev = temp;
            delete p;
            return;
        }
    }
}


template
void List::Clear() 
{
    if (length == 0) 
    {
        return;
    }
    Node *p = head->next;
    Node *temp;
    while (p != tail) 
    {
        temp = p;
        p = p->next;
        delete temp;
    }
    head->next = tail;
    tail->prev = head;
    length = 0;
}

template 
void List::Sort() 
{
    if (length <= 1) return;
    Node *p = head->next;
    for (int i = 0; i < length - 1; i++) 
    {
        Node *q = p->next;
        for (int j = i + 1; j < length; j++) 
        {
            if (p->date > q->date) 
            {
                T temp = p->date;
                p->date = q->date;
                q->date = temp;
            }
            q = q->next;
        }
        p = p->next;
    }
}

template 
bool List::isEmpty()
{
    if (length == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

template 
int List ::szie() 
{
    return length;
}

template 
bool List::IsContain(T e) 
{
    if (length == 0)
    {
        cout << "list is empty";
        return false;
    }
    Node *p = head->next;
    while (p->next != nullptr)
    {       
        if (p->date == e) 
        {
            return true;
        }
        p = p->next;
    }
    return false;
}

template 
void List::Show() 
{
    if (length == 0)
    {
        cout << "list is empty";
        return;
    }
    Node *p = head->next;
    while (p != tail) 
    {
        cout << p->date << "\n";
        p = p->next;
    }
    cout << endl;
}

template 
List::~List() 
{
    if (length == 0) 
    {
        delete head;
        delete tail;
        head = nullptr;
        tail = nullptr;
        return;
    }
    while (head->next != nullptr) 
    {
        Node *temp = head;
        head = head->next;
        delete temp;
    }
    delete head;
    head = nullptr;
}

template 
T List::operator[](int index) 
{
    if (index < 0) 
    {
        cout << "index is OUT bouns";
        return 0;
    }
    
    if (index < 2 / length) {
        Node *p = head;
        int i = 0;
        while (p->next != nullptr)
        {
            p = p->next;
            if (i == index)
            {
                return p->date;
            }
            i++;
        }
    }
    else
    {
        Node *p = tail;
        int i = length;
        while (p->prev!=nullptr)
        {           
            if (i == index) 
            {
                return p->date;
            }
            p = p->prev;
            i--;
        }
    }
    return 0;
}

int result(int a, int b)
{
    return a - b;
};

int main()
{
    Listmylist;
    for (int i = 0; i < 10; i++) 
    {
        mylist.Add(i);
    }
    //cout << mylist[9];
    
    mylist.Sort(result);
    mylist.Show();

    return 0;
}