奇怪的对象赋值行为c ++

Question

我对对象分配有一个奇怪的行为。如果您能解释为什么这项作业会这样工作，我将不胜感激。它已经花费了我很多时间。 我正在使用 Visual Studio Enterprise 2017（所有默认设置）。

代码：

#include "stdafx.h"
#include <iostream>

using namespace std;

class Test
{
public:

    Test()
    {
        cout << "Constructor of " << this << endl;
    }

    ~Test()
    {
        cout << "Destructor of " << this << endl;
    }
};


int main()
{
    cout << "Assignment 1" << endl;
    auto t = Test();
    cout << "Assignment 2" << endl;
    t = Test();

    int i = 0;
    cin >> i;
    return 0;
}

输出（最高为 cin）：

Assignment 1
Constructor of 006FFC9F
Assignment 2
Constructor of 006FFBC7
Destructor of 006FFBC7

预期输出（最高为 cin）：

Assignment 1
Constructor of 006FFC9F
Assignment 2
Destructor of 006FFC9F
Constructor of 006FFBC7

我想编写一个测试函数来创建我的（模板）类的对象，进行一些测试，然后创建一个新对象并进行更多测试。问题是 t 在第二次赋值后保存了已经破坏的对象。 我知道我可以只使用导致预期行为的动态分配，但是为什么这个程序的行为不同？

非常感谢。 问候。

PS：结果是一样的，与 Release/Debug 或 64/32 位编译无关

编辑：更详细的示例：

#include "stdafx.h"
#include <iostream>

using namespace std;

class Test
{
private:
    float* val;
public:
    Test()
    {
        val = new float;
        cout << "Constructor of " << this << ", addr. of val: " << val << endl;
    }

    ~Test()
    {
        cout << "Destructor of " << this << ", addr. of val: " << val << " --> DELETING VAL!" << endl;
        delete val;
    }

    float* getVal() { return this->val; }
};


int main()
{
    cout << "Assignment 1" << endl;
    auto t = Test();
    cout << "Assignment 2" << endl;
    t = Test();
    cout << "Val Address: " << t.getVal() << endl;

    int i = 0;
    cin >> i;
    return 0;
}

输出（它在末尾保存了一个已删除的指针！！！）：

Assignment 1
Constructor of 004FFBDC, addr. of val: 0072AEB0
Assignment 2
Constructor of 004FFB04, addr. of val: 00723928
Destructor of 004FFB04, addr. of val: 00723928 --> DELETING VAL!
Val Address: 00723928

Answer 1

有

auto t = Test();

您实际上构造了 两个 对象。首先是构造一个临时对象的Test()。第二个是t的构造，通过copy-construction进行。这里没有赋值，即使使用=操作符，也是拷贝构造。

如果您在Test 类中添加类似于构造函数和析构函数的复制构造函数，您应该可以清楚地看到它。

---

至于

t = Test();

这里使用Test() 创建了一个临时 对象。然后将该临时对象传递给Test 类的（编译器生成的）赋值运算符，然后立即销毁该临时对象。

对象t 本身没有被破坏，它不应该被破坏，因为它是分配的目的地。

Answer 2

您的困惑似乎是错误地期望原始对象在分配发生时被破坏。就像，在这段代码中：

cout << "Assignment 2" << endl;
t = Test();

这段代码调用了移动赋值运算符。由于您没有定义一个，因此编译器生成的默认值或多或少看起来像这样：

Test & operator=(Test &&) {}

请注意代码中没有调用构造函数或（关键地）析构函数。唯一要运行的构造函数和析构函数在临时对象上（这是您在实际输出中观察到的）。在代码超出范围之前，原始对象不会被销毁；为什么会这样？在此之前你不能停止使用堆栈空间。

编辑：可能会帮助您了解正在发生的事情：

#include<iostream>

struct Test {
    Test() {std::cout << "Constructed.\n";}
    ~Test() {std::cout << "Destructed.\n";}
    Test(Test const&) {std::cout << "Copy-Constructed.\n";}
    Test(Test &&) {std::cout << "Move-Constructed.\n";}
    Test & operator=(Test const&) {std::cout << "Copy-Assigned.\n"; return *this;}
    Test & operator=(Test &&) {std::cout << "Move-Assigned.\n"; return *this;}
};

int main() {
    std::cout << "Test t;\n";
    Test t; //Construction
    std::cout << "Test t2(t);\n";
    Test t2(t); //Copy-Construct
    std::cout << "Test t3(std::move(t2));\n";
    Test t3(std::move(t2)); //Move-Construct
    std::cout << "Test t4 = t;\n";
    Test t4 = t; //Copy Construct, due to Copy Ellision
    std::cout << "Test t5 = Test();\n";
    Test t5 = Test(); //Will probably be a normal Construct, due to Copy Ellision
    std::cout << "t = t2;\n";
    t = t2; //Copy Assign
    std::cout << "t = Test();\n";
    t = Test(); //Move Assign, will invoke Constructor and Destructor on temporary
    std::cout << "Done! Cleanup will now happen!\n";
    return 0;
}

compiled here时看到的结果：

Test t;
Constructed.
Test t2(t);
Copy-Constructed.
Test t3(std::move(t2));
Move-Constructed.
Test t4 = t;
Copy-Constructed.
Test t5 = Test();
Constructed.
t = t2;
Copy-Assigned.
t = Test();
Constructed.
Move-Assigned.
Destructed.
Done! Cleanup will now happen!
Destructed.
Destructed.
Destructed.
Destructed.
Destructed.

双重编辑组合！：

正如我在 cmets 中提到的，val 只是一个指针。作为Test 存储的一部分分配的8 个字节（在64 位机器上）。如果您要确保Test 始终包含尚未删除的val 的有效值，则需要实施Rule of Five（以前称为三规则）：

class Test {
    float * val;
public:
    Test() {val = new float;}
    ~Test() {delete val;
    Test(Test const& t) {
        val = new float(*(t.val));
    }
    Test(Test && t) {std::swap(val, t.val);}
    Test & operator=(Test const& t) {
        float * temp = new float(*(t.val)); //Gives Strong Exception Guarantee
        delete val; 
        val = temp;
        return *this;
    }
    Test & operator=(Test && t) {std::swap(val, t.val); return *this;};

    float & get_val() const {return *val;} //Return by reference, not by pointer, to 
        //prevent accidental deletion.
};