使用将unique_ptr移动到相同对象构造的基类之后，使用指向对象的原始指针初始化字段

问题描述

我有一个Foo拥有的对象Owner，没有其他人。我创建了一个类Derived的对象，该对象继承了Owner，并将其unique_ptr传递给了新创建的Foo。 Derived有一个类User的成员，该成员也需要使用Foo，但它并不拥有它，因此它仅获得指向它的原始指针。

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

struct Foo {
  void talk() { cout << "foo" << endl; }
};

struct User {
  Foo *foo;
  User(Foo *_foo): foo(_foo) {};
  void use() { foo->talk(); } //potential disaster if foo's memory has changed
};

struct Owner {
  unique_ptr<Foo> foo;
  Owner(unique_ptr<Foo> _foo): foo(move(_foo)) {};
};

struct Derived : public Owner {
  User user;
  Derived(unique_ptr<Foo> _foo)
  : Owner {move(_foo)},user{_foo.get()}  //potential disaster: _foo has already been move()'d,can't get()!
  {};
  void use() { user.use(); };
};

int main() {
  Derived d(make_unique<Foo>());
  //do other stuff
  d.use();  //potential disaster
}

问题在于，在Derived的初始化列表中，我需要move() Foo并将其传递给Owner的构造函数（采用{{ 1}}，因为它是所有者），并且还向unique_ptr<Foo>传递了指向Foo的原始指针。但是到User初始化时，User已经被移动，unique_ptr<Foo>可能指向无效的位置！

什么是确保foo.get()获得指向User的有效（非所有权）指针并且Foo仍然获得其Owner的好方法？

解决方法

您可以使基类的成员受到保护（或具有更高的可访问性），并引用基类

Derived(unique_ptr<Foo> _foo)
  : Owner {move(_foo)},user{foo.get()} // refers to Owner::foo

,

您可以在复制指针的同时将工作委托给私有构造函数：

struct Derived : public Owner {
  User user;
  Derived(unique_ptr<Foo> _foo)
  : Derived(move(_foo),_foo.get())
  {};

  void use() { user.use(); };
private:
  // Implement the real logic here
  // As pointed by @Artyer in the comments,this r-value ref is required. 
  // Pass by value would again introduce UB in the calling code.
  Derived(unique_ptr<Foo>&& _foo,Foo* ptr)
   : Owner {move(_foo)},user{ptr} {}
};

请注意，Derived(move(_foo),_foo.get())是安全的，即使未指定评估顺序，因为std::move只是强制转换。

为清楚起见，这不是潜在的灾难，而是一定的灾难 因为初始化列表是从左到右评估的。

9.4.4.4 [dcl.init.list]：

在 大括号初始列表的初始列表，初始子句， 包括任何因包装膨胀（[temp.variadic]）而产生的结果， 按照它们出现的顺序进行评估。 也就是说，每个值 与给定的初始化子句相关的计算和副作用 在每次值计算和相关副作用之前进行排序 与任何以逗号分隔的跟随其后的初始化子句 初始化列表的列表。 [注意：此评估顺序适用 不论初始化的语义如何；例如，它 当初始化列表的元素解释为 构造函数调用的参数，即使通常没有 对调用参数的排序约束。 —尾注] 。

已添加：为什么私有构造函数需要通过引用传递

@Artyer发布了带有反例的正确说明，但很遗憾，此后已将其删除。

有两种合理的方式来编写委托的构造函数：

Derived(unique_ptr<Foo>&& _foo,Foo* ptr) //(A)
Derived(unique_ptr<Foo> _foo,Foo* ptr) //(B) Since the move is cheap.

并假设它是这样命名的：

Derived(move(_foo),_foo.get()) //(1)
Derived{move(_foo),_foo.get()} //(2) @Artyer's idea

首先，通过添加委派的构造函数，我们实质上添加了一个顺序点，该顺序点必须先评估唯一指针和原始指针，然后再将它们分别传递到Owner和User。

第二，必须在实际调用函数之前对函数调用的所有参数进行求值，()的顺序未指定，{}的顺序从左至右（请参见上面的删除段落） ）。

区别在于，如果使用（B），则必须在呼叫处进行复制，对于()，可以在将_foo.get()分配给ptr之前复制该副本。论据。对于{}，它总是会在之前发生。因此错误地设置了ptr。

另一方面，如果选择（A），则仅将r值引用复制到参数中，并且无论ptr或{{1 }}。