Is the destructor deleting the correct instance

I am using Visual C++ in the Community edition of Visual Studio 2022 with the latest updates. In the C++ code below, main creates an instance of ShowBug and assigns it to the variable sb. The next line creates a 2nd instance of ShowBug and also assigns it to sb.

Before the 2nd line completes, it calls the destructor. But, it does not destruct the first instance, which is what I thought it would do, but instead destructs the newly created 2nd instance. Try it yourself if you find it hard to believe.

So, am I missing something here (i.e. is using the same variable to assign a new instance a bad programming practice?), or is the compiler somehow doing the correct thing? Or, is this a compiler bug?

// ShowBug.h:

using namespace std;
#include <iostream>
#include <string>

class ShowBug
{
   // This class is used to show that the destructor seems to be called for the wrong instance.
   //
   string S;
   int *pArray;
public:
   inline ShowBug(const string &s) : S(s)
   {
   }

   inline ~ShowBug()
   {
      std::cout << "Deleting " + S;
   }
};

int main()
{
   ShowBug sb = ShowBug("First Instance");
   sb = ShowBug("Second Instance");
}

</details>


# 答案1
**得分**: 5

在你执行以下代码时：

sb = ShowBug("Second Instance");

表达式`ShowBug("Second Instance")`创建了一个*临时*对象，类型为`ShowBug`。一旦完整表达式（赋值）结束，这个临时对象将会立即被销毁。

当然，这会导致问题，因为它的销毁也会释放分配的内存。指针会被赋值，但**只有**指针本身，而不是指向的内存。

所以，在赋值之后，指针`sb.pArray`将不再有效。除了使用错误的`delete`运算符外，尝试再次`delete`无效指针会导致*未定义行为*。

解决办法是遵循[三五零法则](https://en.cppreference.com/w/cpp/language/rule_of_three)之一。我推荐使用零法则，通过使用`std::vector<int>`或者在你的情况下使用`std::array<int, 3>`，而不是现在所用的动态分配。然后你可以移除析构函数。

如果你必须使用指针和动态分配，那么你至少需要遵循三法则，并且实现一个拷贝构造函数和一个拷贝赋值运算符。

---

我还忽略了初始化：

ShowBug sb = ShowBug("First Instance");

也有相同的问题：你创建了一个临时对象，它用于拷贝构造`sb`对象。然后，临时对象被销毁，带走了内存和原始指针。

然而，解决办法仍然相同：三法则、五法则或零法则。

<details>
<summary>英文:</summary>

When you do

sb = ShowBug("Second Instance");

the expression `ShowBug("Second Instance")` creates a *temporary* object of type `ShowBug`. This temporary object will be immediately destructed once the full expression (the assignment) is finished.

This of course leads to problems, as its destruction also free the memory allocated. The pointer will be copied by the assignment, but *only* the pointer itself and not the memory it points to.

So after the assignment the pointer `sb.pArray` will no longer be valid. Besides the use of the wrong `delete` operator, attempting to `delete` the invalid pointer again leads to *undefined behavior*.

The solution is to follow one of [the rules of three, five or zero](https://en.cppreference.com/w/cpp/language/rule_of_three). I recommend the rule of zero, by using a `std::vector<int>` or in your case `std::array<int, 3>` instead of the dynamic allocation you do now. Then you can remove the destructor.

If you must use pointers and dynamic allocations, then you need to follow at least the rule of three, and implement a copy-constructor as well as a copy-assignment operator.

---

I also overlooked that the initialization

ShowBug sb = ShowBug("First Instance");

have the exact same problem: You create a temporary object, which is used to copy-construct the `sb` object. The temporary object is then destructed, taking the memory and original pointer with it.

The solution is still the same though: The rule of zero, three or five.

</details>