unique_ptr 什么时候需要一个完整的类型？

Question

在下面的代码中，函数f()可以调用unique_ptr<C>的成员函数operator bool()和operator *()，用于不完整的class C。但是，当函数g() 尝试为unique_ptr<X<C>> 调用相同的成员函数时，编译器突然想要一个完整的类型并尝试实例化X<C>，然后失败了。出于某种原因，unique_ptr<X<C>>::get() 不会导致模板实例化并正确编译，如函数h() 所示。这是为什么？ get() 与 operator bool() 和 operator *() 有何不同？

#include <memory>

class C;
std::unique_ptr<C> pC;

C& f() {
    if ( !pC ) throw 0; // OK, even though C is incomplete
    return *pC;         // OK, even though C is incomplete
}

template <class T>
class X
{
    T t;
};

std::unique_ptr<X<C>> pX;

X<C>& g() {
    if ( !pX ) throw 0; // Error: 'X<C>::t' uses undefined class 'C'
    return *pX;         // Error: 'X<C>::t' uses undefined class 'C'
}

X<C>& h() {
    if ( !pX.get() ) throw 0; // OK
    return *pX.get();         // OK
}

class C {};

Answer 1

这是一个人为的简化示例，仅使用我们自己的类型：

class Incomplete;

template <class T>
struct Wrap {
    T t;
};

template <class T>
struct Ptr {
    T* p;

    void foo() { }
};

template <class T>
void foo(Ptr<T> ) { }

int main() {
    Ptr<Incomplete>{}.foo();         // OK
    foo(Ptr<Incomplete>{});          // OK

    Ptr<Wrap<Incomplete>>{}.foo();   // OK
    ::foo(Ptr<Wrap<Incomplete>>{});  // OK!
    foo(Ptr<Wrap<Incomplete>>{});    // error
}

问题是，当我们对foo 进行非限定调用，而不是对::foo 的限定调用或调用成员函数Ptr<T>::foo() 时，我们触发了依赖于参数的查找。

ADL 将在类模板特化中查找模板类型的关联命名空间，这将触发隐式模板实例化。为了执行 ADL 查找，需要触发模板实例化，因为例如，Wrap<Incomplete> 可以声明需要调用的 friend void foo(Ptr<Wrap<Incomplete >> )。或者Wrap<Incomplete> 可能有依赖的基础，它们的命名空间也需要考虑。此时的实例化使代码格式错误，因为Incomplete 是不完整类型，并且您不能拥有不完整类型的成员。

回到最初的问题，对!pX 和*pX 的调用会调用ADL，这会导致X<C> 的实例化，这是格式错误的。对pX.get() 的调用确实不调用ADL，这就是为什么它可以正常工作的原因。

---

更多详情请参阅this answer，另请参阅CWG 557。

Answer 2

需要完整类型的不是unique_ptr，而是你的类X。

std::unique_ptr<C> pC;

您实际上还没有为C 进行任何分配，因此编译器不需要在这里知道C 的细节。

std::unique_ptr<X<C>> pX;

在这里，您使用C 作为X 的模板类型。因为X 包含T 类型的对象，即C，所以编译器需要知道当X 被实例化时要分配什么。 （t 是一个对象，因此在构造时被实例化）。将T t; 更改为T* t;，编译器不会报错。

编辑：

这并不能解释为什么 h() 可以编译，而 g() 却不能。

This example 编译正常：

#include <memory>

class C;
std::unique_ptr<C> pC;

C& f() {
    if (!pC) throw 0; // OK, even though C is incomplete
    return *pC;         // OK, even though C is incomplete
}

template <class T>
class X
{
    T t;
};

std::unique_ptr<X<C>> pX;

typename std::add_lvalue_reference<X<C>>::type DoSomeStuff() // exact copy of operator*
{
    return (*pX.get());
}

void g() {
    if ((bool)pX) return;
}

class C {};

int main()
{
    auto z = DoSomeStuff();
}

这使它更有趣，因为它模仿了 operator* 但确实编译。从表达式中删除 ! 也可以。 这似乎是多个实现（MSVC、GCC、Clang）中的错误。