为什么模板内部的类型检查更严格？

Question

我正在阅读 S. Meyers 的 Effective Modern C++，我发现了一些我无法完全理解的东西。

第 8 条解释了为什么 nullptr 应该优于 0 或 NULL。支持 nullptr 的主要论点是重载决议中更安全的行为。实际上，您可以避免指针和整数类型之间的意外混淆，但这不是我的问题的重点。

要回答我的实际问题，请考虑以下代码，该代码基于书中使用的示例：

#include <memory>

class MyClass {
    int a;
};

// dummy functions that take pointer types
int    f1(std::shared_ptr<MyClass> spw){return 1;};  
double f2(std::unique_ptr<MyClass> upw){return 1.0;};
bool   f3(MyClass* pw){return true;};

// template that calls a function with a pointer argument
template<typename FuncType,
         typename PtrType>
auto CallFun(FuncType func, PtrType ptr) -> decltype(func(ptr))
{
    return func(ptr);
}

int main()
{
    // passing null ptr in three different ways
    // they all work fine int this case
    auto result1 = f1(0);        // pass 0 as null ptr to f1
    auto result2 = f2(NULL);     // pass NULL as null ptr to f2
    auto result3 = f3(nullptr);  // pass nullptr as null ptr to f3 }

    // passing null ptr in three different ways through the template
    // only nullptr works in this case
    auto result4 = CallFun(f1, 0);         // compile error!
    auto result5 = CallFun(f2, NULL);      // compile error!
    auto result6 = CallFun(f3, nullptr);   // OK

    return 0;
}

对 f1、f2 和 f3 的前三个直接调用对于 0、NULL 或 nullptr 编译都很好作为空指针。通过模板函数 CallFun 执行的后续 3 次调用更加挑剔：您必须使用 nullptr，或者在整数类型（0 和 NULL 之间不进行转换) 将被接受。换句话说，当类型检查发生在模板内部时，它似乎更加严格。有人可以澄清发生了什么吗？

Answer 1

CallFun 将 0 和 NULL 的 PtrType 类型推导为 int，这不会隐式转换为指针类型。

如果您想明白我的意思，只需尝试先将 0 和 NULL 存储在 auto 变量中，然后调用 f1 一个 f2 来自那些变量。他们不会编译。

0 和 NULL 本身隐式转换为指针类型，因为我猜它们是文字值。标准中可能有一些关于它的内容，但我想你明白了。

为什么模板内部的类型检查更严格？

Why is type checking inside templates more strict?

c++

templates

types

overloading

c++11