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

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

so IF a new threw std::bad_alloc would there be a memory allocation

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

你有一个比单纯的内存泄漏更严重的错误：

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

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

which means that I should probably do the delete after the new ?

那会好很多，但如果析构函数抛出，它仍然有可能发生内存泄漏。

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

but the thing is if the new throws what will happen to all the new that succeeded in the for loop?
SortedList<T>::SortedList(const SortedList<T>& list):
    data(new smart_ptr<T>[list.max_size])

新[]数组归SortedList::data所有。如果那是一个智能指针，那么应该在它的析构函数中处理它。如果是裸指针，那么指向的数组以及数组内的智能指针都会泄漏。

请注意，由于您分配了一个数组，显示的 smart_ptr::~smart_ptr 不会做正确的事情，因为它没有使用 delete[]。

actually SortedList::~SortedList does delete [] data, would that be enough?

没有。如果 SortedList 的构造函数抛出，则不会调用其析构函数。

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

would memory be leaked if on allocation failed in this code?

c++

memory

smart-pointers

bad-alloc