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也將簡化一些代碼，提高正確性。