如果在此代码中分配失败，内存会泄漏吗？

Question

因此，对于我的家庭作业，我不允许使用std::smart_ptr，但是我可以自己实现它，并进行我想要的任何更改。

所以这就是我所做的

#ifndef SMART_PTR_H_
#define SMART_PTR_H_

template<class T>
class smart_ptr {
    T* data;
public: typedef T element_type;
    explicit smart_ptr(T* ptr = NULL)
   : data(ptr) {}
    ~smart_ptr() {  delete data;    }
    T& operator*() const {  return *data; }
    smart_ptr& operator=(smart_ptr<T>&);
    };
template<class T>
smart_ptr<T>& smart_ptr<T>::operator=(smart_ptr<T>& ptr)
{
    delete this->data;
    T* new_data = new T(*ptr);
    this->data =new_data;
    return *this;
}
#endif

所以我的问题是，对于这样的代码：

template <class T>
SortedList<T>::SortedList(const SortedList<T>& list):
  data(new smart_ptr<T>[list.max_size])
 ,size(list.size)
 ,max_size(list.max_size)
 {
     for (int i = 0; i < size; i++)
     {
        data[i]=list.data[i];// use of operator= of smart_ptr
     }
 }

因此，如果new抛出std::bad_alloc，会有内存分配还是smart_ptr的析构函数会处理所有事情？

Answer 1

，所以如果一个新抛出的std::bad_alloc会有一个内存分配

如果new抛出，那么new将没有分配内存。但是，构造函数有可能已经进行了自己的分配，如果构造函数抛出，实现不当的构造函数可能会泄漏这些分配。

您有一个比仅仅是内存泄漏更严重的bug：

delete this->data;
T* new_data = new T(*ptr);

如果new抛出，那么this->data将留下一个无效的指针。在析构函数中，无效指针将被删除，程序的行为未定义。

，这意味着我可能应该在新的之后执行删除操作？

这样做会好得多，但如果析构函数抛出，它仍有可能发生内存泄漏。

您可能应该将任何一个智能指针的所有权临时转移到第三个本地智能指针。

但是问题是，如果新抛出，那么在for循环中成功的所有新的会发生什么呢？

SortedList::SortedList(const & list)：data(新smart_ptrlist.max_size)

new[]数组属于SortedList::data。如果这是一个智能指针，那么应该在其析构函数中处理它。如果它是一个空指针，那么指向的数组以及数组中的智能指针都会泄漏。

注意，由于您分配了一个数组，所示的smart_ptr::~smart_ptr不会执行正确的操作，因为它不使用delete[]。

实际上是SortedList::~SortedList确实删除了[]数据，这就足够了吗？

不是的。如果SortedList的构造函数抛出，则不会调用它的析构函数。