Не могу освободить мем

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;
}

Семь строк - это строка, котораявызывает ошибку.Строка помечена << -------- ЗДЕСЬ ОШИБКА ПРОВЕРЕНА <br>Спасибо.

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);
}