【C++】实现Myvector和myList

用C++封装静态顺序表：
代码：

#pragma once
#include<iostream>
#include<assert.h>
using  namespace std;

typedef int DataType;
class Myvector
{
public: 
    //析构空Myvector
    Myvector()    
        :_array(new DataType[3])
        , _capacity(3)
        , _size(3)
    {}

    //Myvector中有n个值为data的元素
    Myvector(size_t n, const DataType& data)
        :_array(new DataType[n])
        , _capacity(n)
        , _size(n)
    {
        for (size_t i = 0; i < n; i++)
        {
            _array[i] = data;
        }
    }
    //用【first，last)区间构造Myvector
    Myvector(DataType* first, DataType* last)
    {
        size_t size = last - first;
        _array = new DataType[size];
        _capacity = size;
        _size = size;

        for (size_t i = 0; i < size; i++)
        {
            _array[i] = first[i];
        }
    }

    //拷贝构造函数
    Myvector(const Myvector& v)
        :_array(new DataType[v._capacity])
    {
        memcpy(_array, v._array, v._size*sizeof(DataType));
        _capacity = v._capacity;
        _size = v._size;    
    }
    //赋值运算符重载

    Myvector& operator=(const Myvector& v)
    {
        if (this != &v)
        {
            Myvector tmp(v);
            Swap(tmp);
        }
    }

    //析构函数
    ~Myvector()
    {
        if (_array)
        {
            delete[] _array;
            _array= NULL;
            _capacity = 0;
            _size = 0;
        }
    }

    /*******************************************/
    /*******************************************/
    //随机访问
    DataType& operator[](size_t index)
    {
        assert(index < _size);
        return _array[index];
    }
    const DataType& operator[](size_t index) const
    {
        assert(index < _size);
        return _array[index];
    }
    //获取Myvector的第一个元素
    DataType& Front()
    {
        return _array[0];
    }
    const DataType& Front() const
    {
        return _array[0];
    }
    //获取Myvector中最后一个元素
    DataType& Back()
    {
        return _array[_size - 1];
    }
    const DataType& Back() const
    {
        return _array[_size - 1];
    }

    /*********************************/
    /*********************************/
    size_t Size() const
    {
        return _size;
    }
    size_t Capacity() const
    {
        return _capacity;
    }
    // 将顺序表中元素个数改变到n,多余元素放data
    void Resize(size_t n, const DataType& data)
    {
        size_t oldsize = Size();
        if (n<= oldsize)
            _size = n;
        else//n>oldsize
        {
            if (n <= _capacity)
            {
                for (size_t i = oldsize; i < n; i++)
                    _array[i] = data;
            }
            else //n>capacity需要扩容
            {
                //1. 开辟新空间 
                DataType* pTmp = new DataType[n];

                //2. 拷贝旧空间中的元素
                for (size_t i = 0; i < oldsize; i++)
                {
                    pTmp[i] = _array[i];
                }
                //3.新增加的元素用data来填充
                for (size_t i = oldsize; i < n; i++)
                {
                    pTmp[i] = data;
                }
                //4. 释放旧空间
                delete[] _array;
                _array = pTmp;
                _capacity = n;
                _size = n;

            }
        }
    }
    // 为当前顺序表来预留空间，不能改变顺序表中有效元素的个数
    void Reserve(size_t newCapacity)
    {
        size_t oldcapacity = Capacity();
        if (newCapacity > oldcapacity)
        {
            DataType *tmp = new DataType[newCapacity];
            for (size_t i = 0; i < Size(); ++i)
            {
                tmp[i] = _array[i];
            }
            delete[] _array;
            _array = tmp;
            _capacity = newCapacity;
        }

    }


    /****************************************/
    /***************************************/
    //尾插
    void PushBack(const DataType& data)
    {
        CheckCapacity();
        _array[_size++] = data;
    }
    //尾删
    void PopBack()
    {
        --_size;
    }
    //任意位置插入
    void Insert(size_t pos, const DataType& data)
    {
        assert(pos <= _size);
        size_t tmp = _size;
        if (_size == pos)
        {
            PushBack(data);
        }
        else
        {
            CheckCapacity();
            while (tmp > pos)
            {
                _array[tmp] = _array[tmp - 1];
                --tmp;
            }
            _array[pos] = data;
            _size++;
        }

    }
     //清空
    void Clear()
    {
        _size = 0;
    }
    //任意位置删除
    void Erase(size_t pos)
    {
        assert(pos <= _size);
        if (pos == _size - 1)
        {
            PopBack();
        }
        else
        {
            while (_size > pos)
            {
                _array[pos] = _array[pos + 1];
                pos++;
            }
            _size--;
        }
    }
   //查找
    int Find(const DataType& data)
    {
        assert(_size > 0);
        size_t i = 0;

        while (i < _size)
        {
            if (_array[i] == data)
            {
                return i;
            }
            i++;
        }
        return -1;
    }
private:
    void Swap(Myvector& tmp)
    {
        swap(_array, tmp._array);
        swap(_capacity, tmp._capacity);
        swap(_size, tmp._size);
    }

    void CheckCapacity()
    {
        if (_size == _capacity)
        {
            Reserve(_capacity * 2);
        }
    }
    friend ostream& operator<<(ostream& _cout, const Myvector& v)
    {
        for (size_t i = 0; i < v._size; i++)
        {
            _cout << v._array[i] << " ";
        }
        return _cout;
    }

private:
    DataType* _array;
    size_t _capacity;
    size_t _size;


};

相关测试代码：

void TestVector()
{
    Myvector v1;
    Myvector v2(10, 1);
    cout << v2 << endl;

    Myvector v3(v2);
    cout << v3 << endl;

    int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    Myvector v4(array, array + sizeof(array) / sizeof(array[0]));
    cout << v4 << endl;

    v4.PushBack(7);
    v4.PushBack(8);
    v4.PushBack(9);
    cout << v4 << endl;
    cout << v4.Front() << endl;
    cout << v4.Back() << endl;
    cout << v4.Size() << endl;
    cout << v4.Capacity() << endl;

    v4.PopBack();
    cout << v4 << endl;
    cout << v4.Size() << endl;
    cout << v4.Capacity() << endl;

    v4.Resize(30,5);
    cout << v4 << endl;
    cout << v4.Size() << endl;
    cout << v4.Capacity() << endl;

    size_t pos = v4.Find(6);
    v4.Insert(pos, 0);
    cout << v4 << endl;

    v4.Erase(pos);
    cout << v4 << endl;

    v4.Clear();
    cout << v4.Size() << endl;
}

---

用c++方式封装双向循环链表：
代码：

#pragma once
#include<iostream>

using namespace std;

typedef int DataType;
struct ListNode
{
    ListNode(const DataType& data)
    :_pNext(NULL)
    , _pPre(NULL)
    , _data(data)
    {}

    ListNode* _pNext;
    ListNode* _pPre;
    DataType _data;
};
class MyList
{
public:
    MyList()
    {
        CreateHead();
    }

    MyList(size_t n, const DataType& data)
    {
        CreateHead();
        for (size_t i = 0; i < n; i++)
        {
            PushBack(data);
        }
    }
    MyList(DataType* first, DataType* last)
    {
        CreateHead();
        while (first != last)
        {
            PushBack(*first);
            ++first;
        }
    }

    MyList(const MyList& v)
    {
        CreateHead();
        ListNode* pcur = v._pHead;
        while (pcur->_pNext != v._pHead)
        {
            PushBack(pcur->_data);
            pcur = pcur->_pNext;
        }
    }
    MyList& operator=(const MyList& v)
    {
        if (this != &v)
        {
            MyList tmpList(v);
            Swap(tmpList);
        }
        return *this;
    }

    ~MyList()
    {
        Clear();
        DestroyHead();
    }

    /*****************************/
    /*******************************/

    size_t Size() const
    {
        size_t count = 0;
        ListNode* pCur = _pHead->_pNext;
        while (pCur != _pHead)
        {
            count++;
            pCur = pCur->_pNext;
        }
        return count;
    }
    bool Empty() const
    {
        return _pHead->_pNext == _pHead;
    }

    // 将顺序表中元素个数改变到n,多余元素放data
    void Resize(size_t n, const DataType& data)
    {
        size_t oldsize = Size();
        if (n <= oldsize)
        {
            for (size_t i = n; i < oldsize; i++)
            {
                PopBack();
            }
        }
        else
        {
            for (size_t i = oldsize; i < n; i++)
            {
                PushBack(data);
            }
        }
    }
    /******************************************/
    /******************************************/
    DataType& Front()
    {
        return _pHead->_pNext->_data;
    }
    const DataType& Front() const
    {
        return _pHead->_pNext->_data;
    }

    DataType& Back()
    {
        return _pHead->_pPre->_data;
    }
    const DataType& Back() const
    {
        return _pHead->_pPre->_data;
    }


    /*******************************************/
    /*******************************************/
    void PushBack(const DataType& data)
    {
        ListNode* pNode = new ListNode(data);
        pNode->_pPre = _pHead->_pPre;
        pNode->_pNext = _pHead;
        _pHead->_pPre = pNode;
        pNode->_pPre->_pNext = pNode;
    }
    void PopBack()
    {
        ListNode* pDelNode = _pHead->_pPre;
        if (pDelNode != _pHead)
        {
            _pHead->_pPre = pDelNode->_pPre;
            pDelNode->_pPre->_pNext = _pHead;
            delete pDelNode;
        }

    }

    void PushFront(const DataType& data)
    {
        ListNode* pNew = new ListNode(data);
        pNew->_pPre = _pHead;
        pNew->_pNext = _pHead->_pNext;
        _pHead->_pNext = pNew;
        pNew->_pNext->_pPre = pNew;
    }

    void PopFront()
    {
        ListNode* pDel = _pHead->_pNext;
        if (pDel != _pHead)
        {
            pDel->_pNext->_pPre = _pHead;
            _pHead->_pNext = pDel->_pNext;
            delete pDel;
        }
    }
    void Insert(ListNode *pos, const DataType& data)
    {
        ListNode* pNewNode = new ListNode(data);
        pNewNode->_pPre = pos->_pPre;
        pNewNode->_pNext = pos;
        pNewNode->_pPre->_pNext = pNewNode;
        pos->_pPre = pNewNode;

    }
    void Erase(ListNode *pos)
    {
        if (pos)
        {
            pos->_pPre->_pNext = pos->_pNext;
            pos->_pNext->_pPre = pos->_pPre;
            delete pos;
        }

    }

    void Clear()
    {
        ListNode* pCur = _pHead->_pNext;
        while (pCur != _pHead)
        {
            _pHead->_pNext = pCur->_pNext;
            delete pCur;
            pCur = _pHead->_pNext;
        }
        _pHead->_pPre = _pHead;
        _pHead->_pNext = _pHead;
    }

    ListNode* Find(const DataType& data)
    {
        ListNode* pNode = _pHead->_pNext;
        while (pNode != _pHead)
        {
            if(pNode->_data == data)
            {
                return pNode;
            }
            pNode = pNode->_pNext;
        }
        return NULL;
    }
private:
    void CreateHead()
    {
        _pHead = new ListNode(DataType());
        _pHead->_pNext = _pHead;
        _pHead->_pPre = _pHead;
    }
    void Swap(MyList& tmp)
    {
        swap(_pHead, tmp._pHead);
    }
    void DestroyHead()
    {
        delete _pHead;
        _pHead = 0;
    }

    friend ostream& operator<<(ostream& _cout, const MyList& l)
    {
        ListNode* pCur = l._pHead->_pNext;
        while (pCur != l._pHead)
        {
            cout << pCur->_data << " ";
            pCur = pCur->_pNext;
        }
        return _cout;
    }

private:
    ListNode* _pHead;
};

以下为相关测试代码：

void TestList()
{

    MyList l1;
    MyList l2(10, 4);
    cout << l2 << endl;

    int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    MyList l3(array, array + sizeof(array) / sizeof(array[0]));
    cout << l3 << endl;
    cout << l3.Size() << endl;
    cout << l3.Front() << endl;
    cout << l3.Back() << endl;

    MyList l4=l3;
    cout << l4 << endl;

    l3.PushBack(9);
    l3.PushBack(8);
    l3.PushBack(7);
    l3.PushBack(6);
    cout << l3 << endl;
    cout << l3.Size() << endl;

    l3.PopBack();
    l3.PopBack();
    cout << l3 << endl;
    cout << l3.Size() << endl;

    l3.PushFront(0);
    cout << l3 << endl;
    l3.PopFront();
    cout << l3 << endl;
    cout << l3.Size() << endl;

    l3.Resize(20, 9);
    cout << l3.Size() << endl;
    cout << l3 << endl;

    ListNode* pos = l3.Find(4);
    l3.Insert(pos, 7);
    cout << l3 << endl;

    l3.Erase(pos);
    cout << l3 << endl;

    l3.Clear();
    cout << l3.Size() << endl;

}