C++ 不释放内部单元时内存泄漏？

我的教授编写了以下代码：

template <class T>
Set<T>& Set<T>::operator=(const Set<T>& set) {
  if (this == &set) return *this;
  T* data_temp = new T[set.size];
  try {
    for (int i = 0; i < size; ++i) {
      temp_data[i] = set.data[i];
    }
  } catch (...) {
    delete[] temp_data;
    throw;
  }
  delete[] data;
  data = temp_data;
  size = maxSize = set.size;
  return *this;
}

模板
集合和集合：：运算符=（常量集合和集合）{
如果（this==&set）返回*this；
T*data_temp=新的T[set.size]；
试一试{
对于（int i=0；i

他指出，

temp_data[i]=set.data[i]

调用

操作符=

，我想知道为什么这不会泄漏内存

例如，如果

operator=

在第四个循环中失败，那么我们将删除

temp_数据

，但是

temp_数据

中分配在

operator=

代码中的前3个单元格的值呢？我们不会释放他们

例如，如果

operator=

在第四个循环中失败，那么我们将删除

temp_数据

，但是

temp_数据

中分配在

operator=

代码中的前3个单元格的值呢？我们不会释放他们

new[]

在到达循环之前，分配整个数组并构造其中的所有

T

对象

delete[]

销毁数组中的所有对象，并取消分配整个数组。因此，

T

的构造函数和析构函数负责正确初始化和最终确定

T

的数据成员

循环仅更新数组中对象的数据成员的内容。

T:：operator=

负责根据需要正确复制和释放

T

的数据成员

---

此

Set:：operator=

code中没有泄漏。但是有一个小错误-循环需要使用

set.size

而不是

size

for（int i=0；i

新数组被分配给

set.size

元素数，这就是循环需要复制的元素数

对循环使用

size

，如果分配给的

Set

小于要复制的

Set

，则新数组不会复制所有元素。如果分配给一个更大的

集合

，循环将超出两个数组的界限

---

如果您遇到泄漏，它必须位于

T:：operator=

或

T:：~T（）

中，这两个位置您都没有显示。假设

Set:：Set（）

和

Set:~Set（）

正在正确地初始化和释放

数据，这就是。
让我们从这段代码中删除一些复杂的内容。假设
T==int
，我们只存储一个，而不是存储许多
int
s：

int_store& int_store::operator=(const int_store& set)
{
    int* temp_data = new int;   (1) allocate
    try 
    {
        *temp_data = *set.data;   (2) assign
    }
    catch (...) 
    {
        delete temp_data;       (3) free temp
        throw;
    }
    delete data;                (4) free old 
    data = temp_data;
}

该方法有一个分配
int*temp_data=new int
（1）。它尝试将另一个
set
s数据分配给该临时值（2）。当此操作失败时，必须删除
temp
（3），否则，我们可以使用存储在
temp\u data
中的新数据替换旧的
数据，在此之前，我们必须删除旧数据（4）

try
块中没有分配。在函数中分配的所有内存要么被删除（当分配失败时），要么被用来替换旧数据，在这种情况下，旧的
数据在分配失败之前被删除

如果
data
是一个数组而不是单个
int
（几乎）没有任何变化，也没有泄漏。您担心的元素已经在
T*data\u temp=new T[set.size]行中分配然后
删除[]临时数据
将删除所有这些数据。
data\u temp
vs
temp\u data
，这是打字错误吗？上面的代码没有内存泄漏。您关心哪个操作员
Set:：operator=
或
T:：operator=
上述代码进行一次分配和一次解除分配。因此，它没有内存泄漏。可能在其他代码中分配的任何其他内存都是该其他代码的责任。如果其他代码也已正确编写，则没有内存泄漏。@John但在T:：operator=中，我们正在分配内存…@Josh989不，我们没有。你为什么这么说？但是有一个小错误-循环需要使用set.size而不是size。但它们是最重要的same@Josh989不，它们不一样。想象一下，将包含5个元素的
集合
分配给包含10个元素的
集合
时会发生什么。在循环中，
size
仍将为10，并且
已设置。size
将为5，因此循环将尝试将10个元素从一个5元素数组复制到另一个5元素数组中。