-1

我正在尝试制作一个实现“复制和交换”习语之间交互的程序，move control operations因此我编写了以下代码：

class PInt
{
public:
    PInt(int = 0);
    PInt(const PInt&);
    PInt(PInt&&) noexcept;
    PInt& operator=(PInt);
    ~PInt();

    int* getPtr()const;

private:
    int* ptr;
    friend void swap(PInt&, PInt&);
};

PInt::PInt(int x) : 
    ptr(new int(x))
{
    std::cout << "ctor\n";
}

PInt::PInt(const PInt& rhs) :
    ptr(new int(rhs.ptr ? *rhs.ptr : 0))
{
    std::cout << "copy-ctor\n";
}

PInt::PInt(PInt&& rhs) noexcept :
    ptr(rhs.ptr)
{
    std::cout << "move-ctor\n";
    rhs.ptr = nullptr; // putting rhs in a valid state
}


PInt& PInt::operator=(PInt rhs)
{
    std::cout << "copy-assignment operator\n";
    swap(*this, rhs);
    return *this;
}

PInt::~PInt()
{
    std::cout << "dtor\n";
    delete ptr;
}

void swap(PInt& lhs, PInt& rhs)
{
    std::cout << "swap(PInt&, PInt&\n";
    using std::swap;
    swap(lhs.ptr, rhs.ptr);
}

PInt gen_PInt(int x)
{
    return {x};
}

int main()
{
    PInt pi1(1), pi2(2);
    //pi1 = pi2; // 1
    //pi1 = PInt{}; // 2
    //pi1 = std::move(pi2); // 3
    pi1 = std::move(PInt{}); // 4


}

  • 对我来说一切都很好，所以我认为在1copy-ctor 中由复制分配运算符调用以初始化其参数（它按值获取）然后使用交换。在“2”中，我是从 r 值分配的，因此我认为编译器应用了一些“复制省略”优化；在复制赋值运算符中直接创建一个对象。

  • 我不确定的是 3 和 4。所以这里是 3 和 4 的结果：

    取消注释第 3 行：

    ctor
ctor
move - ctor
copy - assignment operator
swap(PInt&, PInt &
dtor
dtor
dtor

取消注释第 4 行：

    ctor
    ctor
    ctor
    move - ctor
    copy - assignment operator
    swap(PInt&, PInt &
    dtor
    dtor
    dtor
    dtor
  • 为什么要使用 3 和 4 std::move，但要调用 n 个额外的构造函数？

** 哪个是有效的：定义一个复制/移动赋值运算符，取值或两个单独的版本：复制赋值和移动赋值？因为每次调用它的一个版本要么调用（额外调用）copy-ctor 或 move-ctor 来初始化其参数吗？

4

1 回答 1

4

为什么 3 和 4 使用 std::move 但是调用了 n 个额外的构造函数？

3 和 4 的“额外”（移动）构造函数是在此处创建作为参数的对象：

PInt& PInt::operator=(PInt rhs)
                      ^^^^^^^^

4 的“额外”构造函数是创建这个临时的：

pi1 = std::move(PInt{}); // 4
                ^^^^^^
于 2020-02-11T20:09:38.970 回答