复制构造函数和析构函数的奇怪调用[重复]

Question

这个问题不同于所有的：

• Copy constructor calls destructor c++（无关）

• c++ Copy constructors and destructors（无关）

• extraneous calls to copy-constructor and destructor（相关但在我的案例中未使用 STL）

• [为什么类的析构函数被调用了两次？] (Why is the destructor of the class called twice?)（无关）

• Constructor and destructor Calls（无关）

• copy constructor,destructor and temporaries（无关）

堆栈溢出建议。

---

假设你有这个简单的代码。

#include <iostream>
using namespace std;

class Int {

    private:

        int i_;

    public:

        Int(Int &&obj) : i_(obj.i_) { //move constructor
            print_address_change_(&obj);
            cout << i_ << " moved.\n";
        }

        Int(const Int &obj) : i_(obj.i_) { //copy constructor
            print_address_change_(&obj);
            cout << i_ << " copied.\n";
        }

        Int(int i) : i_(i) {
            print_address_();
            cout << i_ << " constructed.\n";
        }

        ~Int() {
            print_address_();
            cout << i_ << " destructed.\n";
        }

        void print_address_() const {
            cout << "(" << this << ") ";
        }

        void print_address_change_(const Int *p) const {
            cout << "(" << p << " -> " << this << ") ";
        }

        const Int operator * (const Int &rhs) const {
            return Int(i_ * rhs.i_);
        }

};

int main() {

    Int i(3);
    Int j(8);

    cout << "---\n";
    Int k = i * j;
    cout << "---\n";

}

结果（由 g++ 7.3.0 使用默认选项）是这个。

(0x7ffd8e8d11bc) 3 constructed. //i
(0x7ffd8e8d11c0) 8 constructed. //j
---
(0x7ffd8e8d11c4) 24 constructed. //tmp
---
(0x7ffd8e8d11c4) 24 destructed. //k
(0x7ffd8e8d11c0) 8 destructed. //j
(0x7ffd8e8d11bc) 3 destructed. //i

好的。有点奇怪，但你可以说copy elision 一定发生了。所以现在使用-fno-elide-constructors 选项，您会得到以下结果。

(0x7ffd8f7693f8) 3 constructed. //i
(0x7ffd8f7693fc) 8 constructed. //j
---
(0x7ffd8f7693c4) 24 constructed. //tmp
(0x7ffd8f7693c4 -> 0x7ffd8f769404) 24 moved. //tmp -> ??? (WHY?)
(0x7ffd8f7693c4) 24 destructed. //tmp
(0x7ffd8f769404 -> 0x7ffd8f769400) 24 copied. //??? -> k (WHY?)
(0x7ffd8f769404) 24 destructed. //??? (WHY?)
---
(0x7ffd8f769400) 24 destructed. //k
(0x7ffd8f7693fc) 8 destructed. //j
(0x7ffd8f7693f8) 3 destructed. //i

这比我预期的多出三行（标记为“WHY”）。 ??? 是什么？谁能告诉我那里发生了什么？

Answer 1

operator* 用Int(i_ * rhs.i_) 构造一个临时对象。它返回该对象，该对象在函数之外构造第二个临时对象。该临时对象被复制到k。

Answer 2

当你写作时：

Int k = i * j;

你实际上是在做类似的事情：

Int tmp1(i.operator*(j));
Int k(tmp1);

也就是说，使用= 进行初始化实际上是通过创建一个临时对象并进行复制构造来使用的。与直接初始化的Int k(i * j) 或Int k{i *j} 进行比较。

在这种情况下并不重要，因为即使你写了Int k(i*j)，在调用k的复制构造函数之前，仍然需要一个临时的来保存operator*的返回值。

operator* 相当于：

Int tmp2(24);
return std::move(tmp2);

所以你的输出意味着：

(0x7ffd8f7693f8) 3 constructed. //i
(0x7ffd8f7693fc) 8 constructed. //j
---
(0x7ffd8f7693c4) 24 constructed. //tmp2 inside operator*
(0x7ffd8f7693c4 -> 0x7ffd8f769404) 24 moved. //return value into tmp1
(0x7ffd8f7693c4) 24 destructed. //tmp2
(0x7ffd8f769404 -> 0x7ffd8f769400) 24 copied. //k = tmp1
(0x7ffd8f769404) 24 destructed. //tmp1
---
(0x7ffd8f769400) 24 destructed. //k
(0x7ffd8f7693fc) 8 destructed. //j
(0x7ffd8f7693f8) 3 destructed. //i