c++ - 为什么内存泄漏只发生在赋值运算符重载的情况下而不发生在复制构造函数中以及 copy-and-swap 习语如何解决它

Question

P.S:我是编程新手，所以请用更简单的术语回答我的疑问。我找到了几个答案，但无法理解。下面是复制构造函数和赋值运算符重载。

template <class T>
Mystack<T>::Mystack(const Mystack<T> &source)            // copy constructor
{
    input = new T[source.capacity];
    top = source.top;
    capacity = source.capacity;
    for (int i = 0; i <= source.top; i++)
    {
        input[i] = source.input[i];
    }
}


template <class T>
Mystack<T> & Mystack<T>::operator=(const Mystack<T> &source)       // assignment operator overload 
{
    input = new T[source.capacity];
    top = source.top;
    capacity = source.capacity;

    for (int i = 0; i <= source.top; i++)
    {
        input[i] = source.input[i];
    }
    return *this;
}

主要功能片段

   Mystack <int> intstack = tempstack; (copy constructor)
    Mystack <int> floatstack, temp_1;
    floatstack = temp_1;  (assignment operator)

理解:我理解我们需要复制和赋值运算符，这样我们就可以在使用堆内存的情况下进行深度复制，这样当我们删除其中一个时就不会出现悬空指针问题对象。

有人可以回答以下问题吗。

1.:我的理解是否正确？

2. :开发人员建议我在赋值运算符中存在内存泄漏。如果是，有人可以解释一下吗？

3. 复制构造函数与赋值运算符的代码或多或少相同，那么为什么我只有在赋值运算符的情况下才会发生内存泄漏，而在复制构造函数中却没有。

4. :万一我真的有内存泄漏。什么神奇的 copy-and-swap 习语解决了内存泄漏问题。

P.S:它不是完整的运行代码。在实际代码中对象确实包含一些数据。请耐心等待!

Answer 1

"Is my understanding correct?"

是的，你似乎明白了。 Rule of Three 最好地描述了完整的原因概念。如果您发现自己必须实现这三个(复制构造函数、赋值操作或析构函数)中的任何一个来管理动态内存，您非常可能需要所有这三个(并且可能更多信息，请参阅文章)。

---

"I have been suggested by developers that I have memory leak in assignment operator. If yes, can some please explain me how?"

您还没有发布您的默认构造函数，但我认为它看起来像这样:

Mystack<T>::Mystack(size_t size = N)
{
    input = new T[size];
    top = 0;
    capacity = size;
}

或类似的东西。现在，让我们看看赋值运算符中发生了什么:

input = new T[source.capacity]; 

嗯，这个对象的 input 中的 old 值刚刚发生了什么？它不再是可达的，并且其中的内存不再是可回收的。它被泄露了。

---

"Copy constructor has more or less same code as assignment operator then how come I have memory leak only in case of assignment operator but not in the copy constructor function."

在您的复制构造函数的复制构造的目标 中，input 没有previous 值。 IE。 input 还没有指向任何东西(怎么可能呢？你刚刚创建了目标对象)。因此，没有泄漏。

---

"In case I really have memory leak. What magic copy and swap idiom does that mem leak gets resolved."

复制交换习语使用复制构造函数创建一个临时持有的值复制，然后使用赋值运算符将对象“guts”与该拷贝交换。这样做时，传出的临时对象将在其析构函数触发时销毁目标对象的原始内容，而目标对象已将临时对象的传入内容的所有权据为己有。

这提供了多个 好处(是的，一个缺点)，and is brilliantly described here .您的代码中的一个简单示例是:

template <class T>
void Mystack<T>::swap(Mystack<T>& src)
{
    std::swap(input, src.input);
    std::swap(top, src.top);
    std::swap(capacity, src.capacity);
}

并且您的赋值运算符变为:

template <class T>
Mystack<T> & Mystack<T>::operator=(Mystack<T> src) // NOTE by-value intentional,
                                                   // invokes copy-ctor.
{
    this->swap(src);
    return *this;
}

现在您有一个复制实现(在复制构造器中)需要管理。此外，如果发生任何异常，它们将在构建值拷贝期间发生，而不是在这里发生。这个对象被污染到不确定状态的机会减少了(好事)

如果您对我之前提到的缺点感到好奇，请考虑自赋值 (x = x;) 如何在这样的范例中发挥作用。老实说，我个人并不认为 self 分配效率低下是一个缺点。如果您的代码经常出现 x = x; 之类的代码，您的设计可能一开始就有一股腐臭味。

---

我强烈建议您阅读 the article有关该概念的其他信息。这是您将在余下的职业生涯中记住的那些可能会改变您的想法的事情之一。