基于C++的STL的vector实现静态链表，要求包含插入，删除，和查找功能

//main.cpp部分
#include"List.cpp"
int  main()
{
    StaticList<int> SL;
    SL.Insert(,);
    SL.Insert(,);
    SL.Insert(,);
    SL.Insert(,);
    SL.Insert(, );
    SL.Insert(, );
    std::cout << "原始的静态链表如下：" << std::endl;
    SL.show();
    SL.Insert(, );
    std::cout << "在静态链表中第2个位置插入100后结果如下：" << std::endl;
    SL.show();
    int m;
    int delete_index = ;
    SL.Delete(m, delete_index);
    std::cout << "删除的对应" << delete_index << "处的值为：" << m << std::endl;
    std::cout << "删除后的静态链表如下：" << std::endl;
    SL.show();

    int find_val = ;
    int index = SL.Find(find_val);
    std::cout << "查找到" << find_val << "在列表中的位置为:" << index << std::endl;
    return ;
}

//List.h

#pragma once

#include<iostream>
#include<vector>

const int MAXSIZE = ;
template<typename ElemType>
class StaticList;

template<typename ElemType>
class Node
{
    friend class StaticList<ElemType>;
private:
    ElemType data;
    int cur;
};

template<typename ElemType>
class StaticList
{
public:

    StaticList();
    virtual ~StaticList();
    bool Insert(const ElemType& v, int index = );
    bool Delete(ElemType& v, int index = );
    int Find(const ElemType v);
    void show()const;

private:
    int NewSpace();
    void DeleteSpace(int index);
    bool Empty()const;
    bool Full()const;
    std::vector<Node<ElemType>*> StList;
    int Length = ;
};

//List.cpp

#include"List.h"
#include<iostream>
#include<algorithm>
template<typename ElemType>
StaticList<ElemType>::StaticList():Length()
{

    for (int i = ; i < MAXSIZE - ; ++i)
    {
        Node<ElemType>* node = new Node<ElemType>();
        StList.push_back(node);
    }

    for (ElemType i = ; i < MAXSIZE - ; ++i)
        (*StList[i]).cur = i + ;
    Node<ElemType>* node = new Node<ElemType>();
    StList.push_back(node);
    (*StList[MAXSIZE - ]).cur = ;

}

template<typename ElemType>
StaticList<ElemType>::~StaticList()
{
    std::for_each(StList.begin(), StList.end(), [](Node<ElemType>* node) { delete node; });
}

template<typename ElemType>
bool StaticList<ElemType>::Insert(const ElemType& v, int index)
{
    if (Full())
    {
        std::cout << "Can't insert element." << std::endl;
        return false;
    }
    if (index< || index>Length + )
    {
        std::cout << "The invalid index" << std::endl;
        return false;
    }
    int k = NewSpace();
    int j = MAXSIZE - ;
    if (k)
    {
        (*StList[k]).data = v;
        for (int i = ; i <= index - ; ++i)
        {
            j = (*StList[j]).cur;
        }
        (*StList[k]).cur = (*StList[j]).cur;
        (*StList[j]).cur = k;
        ++Length;
        return true;
    }
    return false;
}

template<typename ElemType>
bool StaticList<ElemType>::Delete(ElemType& v, int index)
{
    if (Empty())
    {
        std::cout << "Can't delete element in an empty list!\n";
        return false;
    }
    if (index <  || index>Length)
    {
        std::cout << "The invalid index!\n";
        return false;
    }
    int k = MAXSIZE - ;
    int i = ;
    for (; i <= index - ; ++i)
    {
        k = (*StList[k]).cur;
    }
    i = (*StList[k]).cur;
    (*StList[k]).cur = (*StList[i]).cur;
    v = (*StList[i]).data;
    DeleteSpace(i);
    --Length;
    return true;
}

template<typename ElemType>
int StaticList<ElemType>::Find(const ElemType v)
{
    if (Empty())
    {
        std::cout << "Can't find value in an empty List!\n";
        return -;
    }
    int i = ;
    while ( != i && (*StList[(*StList[i]).cur]).data != v)
        i = (*StList[i]).cur;
    ++i;
    if ( == i)
    {
        std::cout << "Can't find the value  " << v << " in the list" << std::endl;
        return -;
    }
    return i;

}

template<typename ElemType>
void StaticList<ElemType>::show()const
{
    if (Empty())
    {
        std::cout << "The List is empty" << std::endl;
        return;
    }
    int k = (*StList[MAXSIZE - ]).cur;
    std::cout << "The List is:" << std::endl;
    for (int i = ; i <= Length; ++i)
    {
        std::cout << (*StList[k]).data << " ";
        k = (*StList[k]).cur;
    }
    std::cout << std::endl;
}

template<typename ElemType>
bool StaticList<ElemType>::Full()const
{
    if (Length > MAXSIZE - )
        return true;
    return false;
}

template<typename ElemType>
bool StaticList<ElemType>::Empty()const
{
    return ( == Length);
}

template<typename ElemType>
void StaticList<ElemType>::DeleteSpace(int index)
{
    (*StList[index]).cur = (*StList[]).cur;
    (*StList[]).cur = index;
}

template<typename ElemType>
int StaticList<ElemType>::NewSpace()
{

    int i = (*StList[]).cur;
    if ((*StList[]).cur)
    {
        (*StList[]).cur = (*StList[i]).cur;
    }
    return i;
}