在这种情况下，Hinnant 的 unique_ptr 实现是否错误地无法将派生类型转换为基类型？

Question

我目前正在尝试使用 Howard Hinnant 的 unique_ptr 实现，并且遇到了编译错误。这是一些示例代码：

struct Base {};

struct Derived : public Base {};

void testfun(boost::unique_ptr<Base>);

void test()
{
    unique_ptr<Derived> testDerived; 
    unique_ptr<Base> testBase(move(testDerived)); // ok, construct base explicitly from derived 
    testfun(move(testBase));                      // ok, pass base to testfun which expects base 
    testfun(unique_ptr<Base>(move(testDerived))); // ok, explicitly converts to unique_ptr<Base>
    testfun(move(testDerived));                   // error on this line
}

我得到的错误是

In function 'void test()':
error: no matching function for call to 'boost::unique_ptr<Base, boost::default_delete<Base> >::unique_ptr(boost::unique_ptr<Base, boost::default_delete<Base> >)'
note: candidates are: boost::unique_ptr<T, D>::unique_ptr(boost::detail_unique_ptr::rv<boost::unique_ptr<T, D> >) [with T = Base, D = boost::default_delete<Base>]
note:                 boost::unique_ptr<T, D>::unique_ptr(boost::unique_ptr<T, D>&) [with T = Base, D = boost::default_delete<Base>]
error:   initializing argument 1 of 'void testfun(boost::unique_ptr<Base, boost::default_delete<Base> >)' from result of 'boost::unique_ptr<T, D>::unique_ptr(boost::unique_ptr<U, E>, typename boost::enable_if_c<((((! boost::is_array<U>::value) && boost::detail_unique_ptr::is_convertible<typename boost::unique_ptr<U, boost::default_delete<U> >::pointer,typename boost::detail_unique_ptr::pointer_type<T, D>::type>::value) && boost::detail_unique_ptr::is_convertible<E,D>::value) && ((! boost::is_reference<D>::value) || boost::is_same<D,E>::value)), void>::type*) [with U = Derived, E = boost::default_delete<Derived>, T = Base, D = boost::default_delete<Base>]'

看起来有问题的行不应该失败。这是实现中的错误，还是由于缺乏 C++0x 语言功能而导致的实现限制，或者是对 unique_ptrs 规则的误解？

（注意，我知道这在运行时不起作用，因为我多次移动同一件事；我只是想找出编译时错误。）

Answer 1

对于类似的示例，请参阅这也应该失败

unique_ptr<Base> testBase = move(testDerived);

这里的问题是如何实现移动语义：“复制构造函数”采用非常量引用，因此无法绑定到临时对象。为了仍然从临时对象中“移动”，该类有一个转换函数（以下实际上只是概念性的 - 它们的详细实现可能有所不同）：

operator rv<T>() { return rv<T>(*this); }

并且构造函数将采用该对象：

unique_ptr(rv<T> r):ptr_(r.release()) { }

这是一个因相同原因而失败的示例：

// move helper. rv<> in unique_ptr
struct E { };

// simulates a unique_ptr<D>
struct D { };

// simulates the unique_ptr<B>
struct A {
  A() { }

  // accepts "derived" classes. Note that for unique_ptr, this will need that
  // the argument needs to be copied (we have a by-value parameter). Thus we 
  // automatically ensure only rvalue derived-class pointers are accepted.
  A(D) { } 

  // these will accept rvalues
  A(E) { }
  operator E() { return E(); }

private:
  A(A&); // private, error if passed lvalue
};

现在，考虑这段代码：

// allowed: goes: D -> A(D)
A a((D()));

// compile failure. Goes:
// D -> A(D) -> A(E)
A a = D();

复制初始化将首先转换为A。但随后，临时 A 对象被尝试再次复制到最终对象。这需要使用operator E的方式。但这是初始化中另一个用户定义的转换，标准禁止这样做：

13.3.3.1/4

当在类复制初始化的第二步中调用临时值的复制时，[...]，仅允许标准转换序列和省略号转换序列。

这就是您的代码失败的原因。

Answer 2

进一步的研究让我看到这篇说明，让我相信这是一个已知的实现限制：

目前有 3 个测试对我来说失败了（在编译时失败，
应该编译、运行并通过）。这些都与
转换 [unique.ptr.single.ctor] 中指定的构造函数。什么时候
源和目标的类型不同，此仿真要求
转换是显式的，并且拒绝隐式编译
转换：

unique_ptr<base> b(unique_ptr<derived>()); // ok

unique_ptr<base> b = unique_ptr<derived>(); // causes 3 compile time failures under unique.ptr/unique.ptr.single/unique.ptr.single.ctor .