复制堆栈变量时出现异常的析构函数行为

Question

我编写了一个测试来检查在对堆栈变量进行覆盖赋值之前是否调用了析构函数，并且我找不到结果的任何合理解释...

这是我的测试（在 Visual C++ 2008 发布模式下）：

#include <iostream>
class C {
public:
 char* ptr;
 C(char p) { ptr = new char[100]; ptr[0] = p;}
 ~C() { std::cout << ptr[0] << ' '; delete [] ptr; }
};

int _tmain(int argc, _TCHAR* argv[])
{
 {
  C s('a');
  s = C('b');
  s = C('c');
  s = C('d');
 }
 std::cin.get();
 return 0;
}

我期待如果我的假设为真，则得到“abcd”；如果假设为假，则得到“d”。 相反，我得到“bcdx”。 “x”根据分配给 ptr 的内存量而变化，表明它正在读取随机堆值。

我相信发生的事情（如果我错了，请纠正我）是每个构造函数调用都会创建一个新的堆栈值（让我们称它们为 s1、s2、s3、s4），然后赋值使 s1.ptr 被 s4.ptr 覆盖。 s4 在复制后立即被销毁，但 s1（带有悬空的 ptr）在离开作用域时被销毁，导致 s4.ptr 的双重删除，并且原始 s1.ptr 没有删除。

有没有什么方法可以解决这种不涉及使用shared_ptrs的无益行为？

编辑：将“删除”替换为“删除[]”

Answer 1

三法则

您的应用程序行为未定义，因为如上所述多个对象将共享对公共指针的访问，并尝试读取它...

三规则表明，每次定义其中之一时：

• 复制构造
• 函数
• 赋值运算符 析

构函数那么您应该定义另一个，因为您的对象具有特定的行为默认生成的方法不知道。

编辑特殊例外：
有时，您定义析构函数只是因为您希望它是虚拟的，或者因为它记录某些内容，而不是因为对您的属性进行了一些特殊处理；）

Answer 2

添加其他编译器定义的方法：

class C
{
    public:
      char* ptr;
      C(char p)                { ptr = new char[100]; ptr[0] = p;}
     ~C()                      { std::cout << ptr[0] << ' '; delete [] ptr; }
      C(C const& c)            { ptr = new char[100]; ptr[0] = c.ptr[0];}
      C& operator=(C const& c) { ptr[0] = c.ptr[0]; return *this;}
};

int _tmain(int argc, _TCHAR* argv[])
{
  {
      C s('a');
      s = C('b');
      s = C('c');
      s = C('d');
  }
  std::cin.get();
  return 0;
}

现在应该打印出：

BCD d

每个临时变量都会在表达式末尾被销毁。然后 s 最后被销毁（在将 'd' 复制到 ptr[0] 之后）。如果您在每个方法中添加打印语句，则可以更轻松地查看发生的情况：

>>           C s('a');
Construct 'a'

>>           s = C('b');
Construct 'b'  
Assign 'b' onto 'a'  
Destroy 'b'         (Temporary destroyed at ';')  

>>          s = C('c');
Construct 'c'  
Assign 'c' onto 'b' (was 'a' but has already been assigned over)  
Destroy 'c'         (Temporary destroyed at ';')

>>          s = C('d');  
Construct 'd'  
Assign 'd' onto 'c'  
Destroy 'd'         (Temporary destroyed at ';')  

>> End of scope.
Destroy 'd'         (Object s destroyed at '}')  

由于编译器定义了 4 个方法，因此适用“四规则”。
如果你的类包含一个由该类拥有的RAW指针（拥有意味着你的对象决定了生命周期）。然后您必须重写所有 4 个编译器生成的方法。

由于您创建并销毁了成员“ptr”，因此这是一个拥有的 ptr。因此必须定义所有四种方法。

Answer 3

由于您在析构函数中进行打印，因此 a 实例将在范围末尾（您看到的 x ）被删除。

分配完成后，其他实例将被删除。这解释了 bcdx。

接下来使用

delete [] ptr; 

代替删除

Answer 4

您可以创建一个复制构造函数和赋值运算符，就像对任何拥有原始指针的类型所做的那样。

Answer 5

s 仅在超出范围时才会被销毁 - 并且正如您所提到的，在程序过程中会被覆盖，因此初始分配被泄漏，最后一个分配被双重删除。

解决方案是重载赋值运算符（并且，正如 Pete 建议的那样，在它们齐头并进时提供一个复制构造函数），在其中您将清理您拥有的数组和给定的副本。

Answer 6

问题是您需要复制构造函数和赋值运算符。由于将一个类分配给另一个类的行，因此会生成浅表副本。这将导致两个类具有相同的 ptr 指针。如果其中一个被删除，另一个指向顶部已释放的内存

Answer 7

您尚未定义赋值或复制运算符。所以发生的事情是这样的：

C s('a');

“s”实例被创建并用“a”初始化。

s = C('b');

这会创建一个临时对象，用“b”对其进行初始化，然后启动默认的赋值运算符，对所有变量进行按位复制，覆盖 s 的 ptr。临时对象被销毁。发出“b”并删除“ptr”（使 s 中的 ptr 无效）。

s = C('c');
s = C('d');

又一样。创建临时对象，用“c”初始化，并用临时对象中分配的 ptr 覆盖 s 中的“ptr”。临时对象被销毁，发出“c”并使 s 中的 ptr 无效。重复 d。

  return 0;
}

最后 s 离开作用域，它的析构函数尝试发出 ptr 的第一个字符，但那是垃圾，因为 ptr 是由最后一个（'d'）临时对象分配和删除的。尝试删除 ptr 应该会失败，因为该内存已被删除。

为了解决这个问题？定义显式复制构造函数和赋值运算符。

class C {
  // other stuff
  C(const C&rhs); // copy constructor
  C& operator=(const c& rhs){ // assignment operator
    a[0] = rhs.a[0];
    return *this;
  }
};