模板类实现顺序表之析构函数

C++版的顺序表，但是我的程序运行后会在析构函数“delete[] _pData”， 这块中断
此时系统提示：顺序表C++版.exe 已触发了一个断点。

 #define _CRT_SECURE_NO_WARNINGS

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

#define length 10

typedef int DataType;

class Vector
{
public:
    // 构造函数
    explicit Vector(size_t capacity = 100)
        :_pData(new DataType[_capacity])
        , _size(0)
    { }



    // 构造函数--有size个值为data的元素
    Vector(size_t n, const DataType& data)
        : _pData(new DataType[_capacity])
        , _size(n)
        , _capacity(100)
    {
        if (n <= _capacity)
        {
            size_t i = 0;
            for (; i < _size; i++)
            {
                _pData[i] = data;
            }
        }
    }



    //拷贝构造函数
    Vector(const Vector& v)
        : _capacity(v._capacity)                            
        , _size(v._size)                                      
    {                                                         
        _pData = new DataType[v._capacity];
                for (size_t idx = 0; idx < _size; ++idx)
                      _pData[idx] = v._pData[idx];
    }



    //析构函数
    ~Vector()
    {
        delete[] _pData;
        _pData = NULL;
        _size = 0;
        _capacity = 0;
    }



    // = 的重载函数
    Vector& operator=(const Vector& v)
    {
        _pData = new DataType[v._capacity];
        _size = v._size;
        for (int i = 0; i < (int)_size; i++)
        {
            _pData[i] = v._pData[i];
        }
        return *this;
    }



    //尾插函数
    void PushBack(const DataType& data)
    {
        if (_size < _capacity)
        {
            _pData[_size] = data;
            _size++;
        }
        else
        {
            int i = 0;
            DataType* tmp = new DataType[_capacity + length];
            for (; i < (int)_size; i++)
            {
                tmp[i] = _pData[i];
            }
            tmp[i] = data;
            _size = i;
            _pData = tmp;
            delete[] tmp;
            tmp = NULL;
        }
    }



    //尾删函数
    void PopBack()
    {
        if (_pData)
        {
            if (_size > 1)
            {
                _size--;
            }
            else
            {
                delete[] _pData;
                _size = 0;
            }
        }
    }



    //插入指定位置、指定数据函数
    void Insert(size_t pos, const DataType& data)
    {
        assert(pos > 0 && pos <= _size);
        int idx = 0;
        if (_size >= _capacity)
        {
            int i = 0;
            DataType* tmp = new DataType[_capacity + length];
            for (; i < (int)_size; i++)
            {
                tmp[i] = _pData[i];
            }
            _pData = tmp;
            delete[] tmp;
            tmp = NULL;
        }
        size_t tmp = _size;
        for (tmp; tmp > pos - 1; tmp--)
        {
            _pData[tmp] = _pData[tmp - 1];
        }
        _pData[pos] = data;
    }


    //删除指定节点函数
    void Erase(size_t pos)
    {
        size_t tmp = _size-pos;
        if (_size > 0)
        {
            int idx = 0;
            for (pos; pos < tmp; pos++)
            {
                _pData[pos-1] = _pData[pos];
            }
        }
    }



    //查找函数
    int Find(const DataType& data)const
    {
        int idx = 0;
        for (idx = 0; idx < (int)_size; idx++)
        {
            if (data == _pData[idx])
            {
                break;
            }
        }
        return idx;
    }



    //清空函数
    void Clear()
    {
        _size = 0;
        _capacity = 0;
        delete[] _pData;
        _pData = NULL;
    }



    //求长度函数
    size_t Size()const
    {
        return _size;
    }



    //改变表长函数
    void ReSize(size_t size, const DataType& data = DataType())
    {
        size_t max = _size + size;
        for (_size; _size < max; _size++)
        {
            _pData[_size] = data;
        }
    }



    //求最大容量函数
    size_t Capacity()const
    {
        return _capacity;
    }



    //判空函数
    bool Empty()const
    {
        if (0 == _size)
            return true;
        else
            return false;
    }



    //返回第一个节点的数据
    DataType& Front()
    {
        if (_size > 0)
        {
            return _pData[0];
        }
    }
    const DataType& Front()const
    {
        if (_size > 0)
        {
            return _pData[0];
        }
    }



    //返回最后一个节点的数据
    DataType& Back()
    {
        if (_size > 0)
        {
            return _pData[_size-1];
        }
    }
    const DataType& Back()const
    {
        if (_size > 0)
        {
            return _pData[_size - 1];
        }
    }



    //置数函数
    void Assign(size_t n, const DataType& data = DataType())
    {
        int idx = 0;
        for (idx=0; idx < (int)n; idx++)
        {
            _pData[idx] = data;
        }
        _size = idx;
    }



    //[]的重载函数
    DataType& operator[](size_t index)
    {
        if (_size > 0)
        {
            return _pData[index];
        }
    }
    const DataType& operator[](size_t index)const
    {
        if (_size > 0)
        {
            return _pData[index];
        }
    }




    DataType& At(size_t index)
    {
        if (_size > 0)
        {
            return _pData[index];
        }
    }
    const DataType& At(size_t index)const
    {
        if (_size > 0)
        {
            return _pData[index];
        }
    }

private:
    //判断容量是否已满
    bool _CheckCapacity()
    {
        if (_size < _capacity)
        {
            return true;
        }
        else
            return false;
    }



    // <<的重载函数
    friend std::ostream& operator<<(std::ostream& _cout, const Vector& v);
private:
    DataType* _pData;
    size_t _capacity;
    size_t _size;
};



std::ostream& operator<<(std::ostream& os, const Vector& v)
{
    int idx = 0;
    for (idx = 0; idx < (int)v._size; idx++)
    {
        os << v._pData[idx];
        cout << " ";
    }
    return os;
}

int main()
{
    Vector v1(5,1);
    v1[1] = 2;
    v1[2] = 3;
    v1[3] = 4;
    v1[4] = 5;
    cout << v1 << endl;
    system("pause");
    return 0;
}

调试你的代码，你的代码存在对同一个指针两次释放，或者对没有初始化/无效的指针调用delete释放的问题。