메모리 할당 해제시 액세스 위반이 발생했습니다.

Question

현재 Accelerated C++를 사용 중이며 CH11에 내 버전을 만들려고합니다. 소멸자를 통해 메모리를 할당 해제하려고 할 때 비어있는 "Vec"를 만들거나 푸시 백을 사용하여 읽기 액세스 메모리를 얻습니다. 나는 내가 무엇을 놓쳤는 지 정말로 모른다. 도움 주셔서 감사합니다.

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

return 0; 
} 

/////////

두 생성자 SB가 create() 이전에 사용되는 지적 이니셜 라이저 목록 이전 사용에 (자신의 멤버를 초기화해야

#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

결정된 값들이 할당 됨). 소멸자가 해고되면 당신은 불확정 포인터 값을 사용하고 그것을 할당 해제하기 위해 보낼 수 있습니다.

변경이 : 여기에

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

:`생성()`초기화되지 않은 값을 사용 할 수있는

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