C++：内存泄漏；类向量类

Question

我是 C++ 初学者，尝试创建类似于 Vector 的容器类。此类应该像 Vector 一样适用于所有类型的数据，并且可以在基于范围的 for 循环中使用。 我写了hpp，但是我的导师说有内存泄漏，我想我删除了所有的动态内存，问题可能出在哪里？

#include "stdafx.h"
using namespace std;
template<class T>
class Customvector
{
public:
    Customvector();
    ~Customvector();
    int size();
    int free_capacity();
    void add(T& temp);
    int& operator[](int index);
    void grow();

    class iterator {
        public:
            iterator(T* ptr) : ptr(ptr) {}
            iterator operator++() { iterator i(ptr); ++ptr; return i; }
            bool operator!=(const iterator & other) { return ptr != other.ptr; }
            const T& operator*() const { return *ptr; } 
        private:
            T* ptr;
        };

    iterator begin() const { return iterator(&_elements[0]); }
    iterator end() const { return iterator(&_elements[0]+_size); }
private:
    T*  _elements;
    int _size;
    int _capacity;
    int DEFAULT_CAPACITY;
};

template<class T>
Customvector<T>::Customvector()
{
    DEFAULT_CAPACITY = 4;
    _capacity = DEFAULT_CAPACITY;
    _size = 0;
    _elements = new T[_capacity];

}
template<class T>
Customvector<T>::~Customvector()
{
    delete[] _elements;

}
template<class T>
void Customvector<T>::add(T& temp)
{
    grow(); //check if the capacity is full, if so,increase capacity by DEFAULt_CAPACITY;
    _elements[_size++]= temp;

}
template<class T>
int Customvector<T>::size()
{
    return _size;
}

template<class T>
int Customvector<T>::free_capacity()
{
    int free_c = _capacity - _size;
    return free_c;
}


template<class T>
int& Customvector<T>::operator[](int index) {
    if (index<0 || index>_capacity)
    {
        cout << "index beyond limit" << endl;
        return _elements[0];
    };
    return _elements[index];
}

template<class T    >
void Customvector<T>::grow() 
{ 
    if (_capacity == _size) 
    {
        _capacity += DEFAULT_CAPACITY;
        T* p = new T[_capacity];
        std::copy(_elements, _elements + _size,p);
        delete[] _elements;
        _elements = p;
    };

}

Answer 1

我能找到的唯一泄漏案例是grow：

    ...
    T* p = new T[_capacity];
    std::copy(_elements, _elements + _size,p); // may throw an exception
    delete[] _elements;
    _elements = p;
    ...

如果复制包含的元素抛出异常，则_elements 仍指向旧数组，而p 指向的新数组会泄漏。你可以通过unique_ptr解决这个问题：

std::unique_ptr<T[]> p(new T[_capacity]);
std::copy(_elements, _elements + _size, p.get()); // it's OK if this throws, unique_ptr will take care of the memory
delete[] _elements;
_elements = p.release();

将unique_ptr 用于_elements 也会简化一些代码并提高正确性。