Не удается освободить MEM

Question

Почему в этом коде (это просто рабочий код, а не полностью исключение безопасного) я получаю ошибку утверждения:
HEAP_CORRUPTION_DETECTED ...

class Allocator 
{ 

public: 

    explicit Allocator() 
    { 
     std::cout << "Allocator()" << '\n'; 
    } 

    virtual ~Allocator() 
    { 

     std::cout << "~Allocator()" << '\n'; 
    } 

    template<class T> 
    T* Allocate(const std::size_t count) 
    { 
     return static_cast<T*>(::operator new(count)); 
    } 

    /*[nothrow]*/ 
    template<class T> 
    void Construct(void* where_, const T& what) 
    { 
     new (where_) T(what); 
    } 

    template<class T> 
    void Destruct(T* where_) 
    { 
     where_->~T(); 
    } 

    template<class FwdIter> 
    void Destruct(FwdIter first, FwdIter last) 
    { 
     while (first != last) 
     { 
      this->Destruct(&*first); 
      ++first; 
     } 
    } 

    template<class T> 
    void Deallocate(T* where_) 
    { 
     ::operator delete(where_); 
    } 
}; 


template<class T> 
class ToyImplementation 
{ 
private: 

public: 
    typedef T value_type; 
    T* data_;///move to private 
    std::size_t size_; 
    std::size_t capacity_; 
    explicit ToyImplementation(Allocator& alloc, const std::size_t count):data_(alloc.Allocate<value_type>(count)),size_(0),capacity_(count) 
    { 
     std::cout << "ToyImplementation()" << '\n'; 
     //throw std::exception(); 
    } 
    ~ToyImplementation() 
    { 
     std::cout << "~ToyImplementation()" << '\n'; 
    } 
}; 


template<class T> 
class ToyA 
{ 
private: 
    ToyImplementation<T>* implementation_; 
    typedef ToyImplementation<T> value_type; 
    Allocator alloc_; 
public: 
    explicit ToyA(const std::size_t count = 0): implementation_(alloc_.Allocate<value_type>(sizeof(value_type))) 
    { 
     alloc_.Construct(implementation_, value_type(alloc_,count)); 
     alloc_.Deallocate(implementation_);//<<--------HERE ERROR IS TRIGGERED 
     std::cout << "Toy()" << '\n'; 
    } 
    ~ToyA() 
    { 
     std::cout << "~Toy()" << '\n'; 
    } 
}; 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    ToyA<int> t(10); 
    return 0; 
} 

Семь линий вверх является линией, вызывает ошибку. Строка отмечена < < -------- ЗДЕСЬ ОШИБКА ТРЕТЬЕРА
Спасибо.

Answer 1

Вы испортили свою кучу, потому что ваше распределение неверно. А именно, рассмотрим это:

template<class T> 
T* Allocate(const std::size_t count) 
{ 
    return static_cast<T*>(::operator new(count)); 
} 

count Если есть один, вы получаете один байт. (Тогда Вы пытаетесь построить объект, который имеет размер больше единицы в этой памяти ... бум.)

Вы, вероятно, хотите:

template<class T> 
T* Allocate(const std::size_t count) 
{ 
    return static_cast<T*>(::operator new(sizeof(T) * count)); 
} 

---

Примечание ваша конструкция функция немного неортодоксальные , Функции распределения и освобождения должны строго распределять и освобождать (не слепки!), Как это:

template<class T> 
void* Allocate(const std::size_t count) 
{ 
    return ::operator new(sizeof(T) * count); 
} 

void Deallocate(void* where_) 
{ 
    ::operator delete(where_); 
} 

И ваши строительство и разрушение функции должны быть те, которые конструируют и возвращают объект, и деструктор объекта:

template<class T> 
T* Construct(void* where_, const T& what) 
{ 
    return new (where_) T(what); 
}