顺序表类模板

记录一下自己写的一个顺序表类模板，运算符只重写了[]，由于函数中直接用了==运算符，如果模板类的类型是复杂数据类型的话，需要在类中重写==等运算符。

链表类模板

#pragma once

#include <iostream>
using namespace std;

template <typename T>
class List
{
public:
    List(unsigned int size);
    ~List();
    void ClearList();                               //清空表
    bool ListEmpty();                               //判空
    int ListLength();                               //求表长
    bool GetElem(unsigned int i, T *e);             //得到i位置元素
    int LocateElem(T *e);                           //定位
    bool PriorElem(T *currentElem, T *preElem);     //获得指定元素前驱
    bool NextElem(T *currentElem, T *nextElem);     //获得指定元素后继
    void ListTraverse();                            //遍历
    bool ListInsert(unsigned int i, T *e);          //定位插入
    bool ListDelete(unsigned int i, T *e);          //定位删除
public:
    T& operator[](int index);

private:
    T *m_pList;
    unsigned int m_iSize;
    unsigned int m_iLength;
};

template <typename T>
List<T>::List(unsigned int size)
{
    m_iSize = size;
    m_pList = new T[m_iSize];
    m_iLength = 0;
}

template <typename T>
List<T>::~List()
{
    delete[] m_pList;
    m_pList = NULL;
}

template <typename T>
void List<T>::ClearList()
{
    m_iLength = 0;
}

template <typename T>
bool List<T>::ListEmpty()
{
    return 0 == m_iLength;
}

template <typename T>
int List<T>::ListLength()
{
    return m_iLength;
}

template <typename T>
bool List<T>::GetElem(unsigned int i, T *e)
{
    if (i < 0 || m_iSize <= i)
    {
        return false;
    }
    else
    {
        *e = m_pList[i];
        return true;
    }
}

template <typename T>
int List<T>::LocateElem(T *e)
{
    for (unsigned int i = 0; i < m_iLength; ++i)
    {
        if (*e == m_pList[i])
        {
            return i;
        }
    }
    return -1;
}

template <typename T>
bool List<T>::PriorElem(T *currentElem, T *preElem)
{
    int temp = LocateElem(currentElem);
    if (temp == -1)
        return false;
    else
    {
        if (temp == 0)
            return false;
        else
        {
            *preElem = m_pList[temp - 1];
            return true;
        }
    }
}

template <typename T>
bool List<T>::NextElem(T *currentElem, T *nextElem)
{
    unsigned int temp = LocateElem(currentElem);
    if (temp == -1)
        return false;
    else
    {
        if (temp + 1 >= m_iLength)
            return false;
        else
        {
            *nextElem = m_pList[temp + 1];
            return true;
        }
    }
}

template <typename T>
void List<T>::ListTraverse()
{
    for (unsigned int i = 0; i < m_iLength; ++i)
    {
        cout << m_pList[i] << endl;
    }
}

template <typename T>
bool List<T>::ListInsert(unsigned int i, T *e)
{
    if (i < 0 || i > m_iLength)
    {
        return false;
    }
    if (m_iLength >= m_iSize)
    {
        return false;
    }

    for (unsigned int k = m_iLength - 1; m_iLength != 0 && k >= i; k--)
    {
        m_pList[k + 1] = m_pList[k];
    }

    m_pList[i] = *e;
    m_iLength++;
    return true;
}

template <typename T>
bool List<T>::ListDelete(unsigned int i, T *e)
{
    if (i < 0 || i >= m_iLength)
    {
        return false;
    }

    *e = m_pList[i];
    for (unsigned int k = i; k < m_iLength - 1; ++k)
    {
        m_pList[k] = m_pList[k + 1];
    }
    m_iLength--;
    return true;
}


template <typename T>
T& List<T>::operator[](int index)
{
    return *(m_pList + index);
}

模板类型

这里放一个模板的实例，此处还实现了几个运算符的重载。

Person.h

#pragma once

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

class Person
{
    friend ostream &operator<<(ostream &out, Person &person);
public:
    string name;
    string phone;
    Person& operator =(Person &person);
    bool operator == (Person &person);
};

Person.cpp

#include "Person.h"


ostream &operator<<(ostream &out, Person &person)
{
    out << person.name << "----------" << person.phone << endl;
    return out;
}


Person& Person::operator =(Person &person)
{
    this->name = person.name;
    this->phone = person.phone;
    return *this;
}

bool Person::operator == (Person &person)
{
    return (this->name == person.name && this->phone == person.phone);
}