我正在尝试制作一种自动创建包装对象的包装器类:

#include <memory>
#include <type_traits>

template<typename T>
class Foo {
    std::unique_ptr<T> _x;
public:
    Foo();  // will initialize _x
};

此外，我希望能够隐藏 T 的实现细节来自 Foo<T> 的用户(对于 PIMPL pattern )。对于单翻译单元示例，假设我有

struct Bar;  // to be defined later

extern template class Foo<Bar>;
// or just imagine the code after main() is in a separate translation unit...

int main() {
    Foo<Bar> f;  // usable even though Bar is incomplete
    return 0;
}

// delayed definition of Bar and instantiation of Foo<Bar>:

template<typename T>
Foo<T>::Foo() : _x(std::make_unique<T>()) { }

template class Foo<Bar>;
struct Bar {
    // lengthy definition here...
};

一切正常。但是，如果我想要求T派生自另一个类，编译器会提示 Bar不完整:

struct Base {};

template<typename T>
Foo<T>::Foo() : _x(std::make_unique<T>()) {
    // error: incomplete type 'Bar' used in type trait expression
    static_assert(std::is_base_of<Base, T>::value, "T must inherit from Base");
}

尝试使用 static_cast 实现相同的检查同样失败:

template<typename T>
Foo<T>::Foo() : _x(std::make_unique<T>()) {
    // error: static_cast from 'Bar *' to 'Base *', which are not related by inheritance, is not allowed
    // note: 'Bar' is incomplete
    (void)static_cast<Base*>((T*)nullptr);
}

但是，似乎如果我添加另一个 级别的函数模板，我就可以完成这项工作:

template<typename Base, typename T>
void RequireIsBaseOf() {
    static_assert(std::is_base_of<Base, T>::value, "T must inherit from Base");
}

// seems to work as expected
template<typename T>
Foo<T>::Foo() : _x((RequireIsBaseOf<Base, T>(), std::make_unique<T>())) { }

请注意，尽管结构相似，但以下内容仍会导致不完整类型的错误:

// error: incomplete type 'Bar' used in type trait expression
template<typename T>
Foo<T>::Foo() : _x((std::is_base_of<Base, T>::value, std::make_unique<T>())) { }

这是怎么回事？附加功能是否以某种方式延迟了 static_assert 的检查？是否有更简洁的解决方案，不涉及添加功能，但仍允许放置 template class Foo<Bar>;在 Bar 的定义之前？

最佳答案

版本 1

// #1
// POI for Foo<Bar>: class templates with no dependent types are instantiated at correct scope BEFORE call, with no further lookup 
// after first parse
int main() {
    Foo<Bar> f;  // usable even though Bar is incomplete
    return 0;
}

// delayed definition of Bar and instantiation of Foo<Bar>:


struct Base {};

// error: incomplete type 'Bar' used in type trait expression
template<typename T>
Foo<T>::Foo() : _x(std::make_unique<T>()) {
    // error: incomplete type 'Bar' used in type trait expression
    static_assert(std::is_base_of<Base, T>::value, "T must inherit from Base");
}
// #2
// POI for static_assert: function templates with no dependent types are
// instantiated at correct scope AFTER call, but no further lookup is
// performed, as with class templates without dependent types
// is_base_of forces the compiler to generate a complete type here

template class Foo<Bar>;
struct Bar : private Base {
    // lengthy definition here...
};

版本 2:

    struct Base {};
template<typename Base, typename T>
void RequireIsBaseOf() {
    static_assert(std::is_base_of<Base, T>::value, "T must inherit from Base");
}

// seems to work as expected
template<typename T>
Foo<T>::Foo() : _x((RequireIsBaseOf<Base, T>(), std::make_unique<T>())) { }
// #3
// is_base_of does not force any complete type, as so far, only the 
// incomplete type of RequiredIsBaseOf is around.

template class Foo<Bar>;
struct Bar : private Base {
    // lengthy definition here...
};
// #3
// POI for RequiredIsBaseOf: function templates WITH dependent types are instantiated at correct scope AFTER call, after the second phase of two-phase lookup is performed. 

这是我认为的问题: 根据规则，#2 之后的任何点都是允许的 POI(Point Of Instantiation，编译器放置专用模板代码的位置)。

In practice, most commpilers delay the actual instantiation of most function templates to the end of the translation unit. Some instantiations cannot be delayed, including cases where instantiation is needed to determine a deduced return type and cases where the function is constexpr and must be evaluated to produce constant result. Some compilers instantiate inline functions when they're first used to potentially inline the call right away. This effectively removes the POIs of the corresponding template specializations to the end of the translation unit, which is permitted by the C++ standard as an alternative POI (from C++ Templates, The Complete Guide, 2nd Ed., 14.3.2. Points of Instantiation, p.254)

std::is_base_of需要一个完整的类型，所以当它没有被 RequiredIsBaseOf 隐藏时，它可以作为函数模板被部分实例化，is_base_of 可以让插入 POI 的编译器尽快发出一个错误。

正如 t.niese 所指出的，godbolt 上任何可以采用 -std=c++17 标志的 gcc 版本都适用于任一版本。我的猜测是 gcc 做了一个迟到的 POI 事情，而 clang 使用了第一个合法的事情，#2。使用具有依赖名称的函数模板(第一次遇到 RequiredIsBaseOf 时，仍然需要填写 T)强制 clang 为依赖类型执行第二次查找运行，此时 Bar 已经遇到了。

不过我不确定如何实际验证这一点，因此欢迎更精通编译器的人提供任何意见。

关于c++ - 在显式实例化过程中什么时候可以使用不完整的类型？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/50578470/