取消分配内存时发生访问冲突

Question

I'm currently going through Accelerated C++ and I'm trying to create my version of in CH11. When trying to deallocate the memory through the destructor I get the read access memory whether I create an empty "Vec" or one using pushback. I'm not really sure what I'm missing. Thanks for any help.

#include "Vec.h"
int main()
{
Vec<int> v;

return 0;
}

/////////

#include <algorithm>
#include <cstddef>
#include <memory>


using std::max;

/////////////////////////////
template <class T> class Vec {
public:
    typedef T* iterator;
    typedef const T* const_iterator;
    typedef size_t size_type;
    typedef T value_type;
    typedef T& reference;
    typedef const T& const_reference;

    //Constructor
    Vec() { create();}
    explicit Vec(size_type n, const T& = T()) {create(n,t);}

    //Copy
    Vec(const Vec& v) {create(v.begin(), v.end());}
    //Assignment
    Vec& operator=(const Vec&);
    //Destructor
    ~Vec() { uncreate();}

    //Indexing
    T& operator[](size_type i) {return data[i]; }
    const T& operator[](size_type i) const { return data[i]; }



    //Size
    size_type size() const { return avail - data; } 

    //Return member variables
    iterator begin() { return data; }
    const_iterator begin() const { return data; }

    iterator end() { return avail; }
    const_iterator end() const {return avail; }

    //Uncreate
    void clear() { uncreate(); }
    //Check empty
    bool empty() const { return data == avail; }
//////////////////////
private:
    iterator data; //first
    iterator avail; //(one past) last element
    iterator limit; //(one past) allocated memory

    std::allocator<T> alloc; // object for memory allocation

    //allocate and initialize thorugh constructors
    void create();
    void create( size_type, const T&);
    void create(const_iterator, const_iterator);

    //destory 
    void uncreate();


};
////////////////////////////
template <class T> void Vec<T>::create()
{
    data = avail = limit;
}

template <class T> void Vec<T>::create(size_type n, const T& val)
{
    data = alloc.allocate(n , 0);
    limit = avail = data + n;
    std::uninitialized_fill(data, limit, val);
}

template <class T> void Vec<T>::create(const_iterator i, const_iterator j)
{
    data = alloc.allocate(j - i, 0);
    limit = avail = std::uninitialized_copy(i , j, data);
}

template <class T> void Vec<T>::uncreate()
{
    if(data) {
        iterator it = avail;
        while(it != data)
            alloc.destroy(--it);
        alloc.deallocate(data, limit - data);
    }
    data = limit = avail = 0;
}

Answer 1

Both constructors need to initialize their members in an initializer list prior to usage, (which SB pointed out are being used in create() prior to having been assigned determinate values). When the destructor is fired you may well be using a indeterminate pointer value, and sending it to be deallocated.

Change this:

Vec() { create();}
explicit Vec(size_type n, const T& = T()) {create(n,t);}

To this:

Vec() : data(), avail(), limit() { create();}
explicit Vec(size_type n, const T& t = T()) 
    : data(), avail(), limit() {create(n,t);}