在函数调用中，为什么 nullptr 不匹配指向模板对象的指针？

Question

这是一个完美运行的代码示例：

---

#include<iostream>
#include<vector>

template< class D, template< class D, class A > class C, class A = std::allocator< D > >
void foo( C< D, A > *bar, C< D, A > *bas ) {
  std::cout << "Ok!" << std::endl;
}

int main( ) {
  std::vector< int > *sample1 = nullptr;
  std::vector< int > *sample2 = nullptr;
  foo( sample1, sample2 );
  return( 0 );
}

---

然而，在下面的代码中，编译器无法将第二个参数的 std::vector* 与 nullptr 匹配，甚至无法从第一个参数中扣除模板类型。

---

#include<iostream>
#include<vector>

template< class D, template< class D, class A > class C, class A = std::allocator< D > >
void foo( C< D, A > *bar, C< D, A > *bas ) {
  std::cout << "Ok!" << std::endl;
}

int main( ) {
  std::vector< int > *sample = nullptr;
  foo( sample, nullptr );
  return( 0 );
}

---

错误信息是：

---

$ g++ -std=c++11 nullptr.cpp -o nullptr

nullptr.cpp: In function ‘int main()’:

nullptr.cpp:11:24: error: no matching function for call to ‘foo(std::vector<int>*&, std::nullptr_t)’

   foo( sample, nullptr );

nullptr.cpp:11:24: note: candidate is:

nullptr.cpp:5:6: note: template<class D, template<class D, class A> class C, class A> void foo(C<D, A>*, C<D, A>*)

 void foo( C< D, A > *bar, C< D, A > *bas ) {

nullptr.cpp:5:6: note:   template argument deduction/substitution failed:

nullptr.cpp:11:24: note:   mismatched types ‘C<D, A>*’ and ‘std::nullptr_t’

   foo( sample, nullptr );

---

为什么会这样？

Answer 1

这就是模板推导的工作原理：不会发生转换。

这个问题也不是 nullptr 特有的问题，考虑一个极其简单的情况：

#include <iostream>

struct Thing {
    operator int() const { return 0; }
} thingy;

template <typename T>
void print(T l, T r) { std::cout << l << " " << r << "\n"; }

int main() {
    int i = 0;
    print(i, thingy);
    return 0;
}

yields:

prog.cpp: In function ‘int main()’:
prog.cpp:12:17: error: no matching function for call to ‘print(int&, Thing&)’
  print(i, thingy);
                 ^
prog.cpp:12:17: note: candidate is:
prog.cpp:8:6: note: template<class T> void print(T, T)
 void print(T l, T r) { std::cout << l << " " << r << "\n"; }
      ^
prog.cpp:8:6: note:   template argument deduction/substitution failed:
prog.cpp:12:17: note:   deduced conflicting types for parameter ‘T’ (‘int’ and ‘Thing’)
  print(i, thingy);
                 ^

因此，nullptr 到 int* 的转换也不会发生在模板参数推导之前。如前所述，您有两种解决问题的方法：

• 指定模板参数（因此不会发生扣除）
• 自己转换参数（推理发生，但在您显式转换之后）

Answer 2

来自 C++ 标准（4.10 指针转换 [conv.ptr]）

1 空指针常量是整数类型的整型常量表达式 (5.19) prvalue 求值为 0 或 std::nullptr_t 类型的纯右值。空指针常量可以是 转换为指针类型；结果是该类型的空指针值，并且是 可与对象指针或函数指针类型的所有其他值区分开来。这样一个 转换称为空指针转换。

在您的第一个示例中，您的两个 nullptr 在模板参数推导之前已经被转换。所以你有两次相同的类型是没有问题的。

在第二个中，std::vector<int> 和 std::nullptr_t 不匹配。您必须自己进行转换：static_cast<std::vector<int>*>(nullptr)。

Answer 3

编译器无法推断出第二个参数类型，因为std::nullptr_t 不是指针类型。

¹ 指针字面量是关键字 nullptr。它是一个 std::nullptr_t 类型的纯右值。 [注意：std::nullptr_t 是一个不同的 既不是指针类型也不是指向成员类型的指针的类型； 相反，这种类型的纯右值是一个空指针常量，可以 转换为空指针值或空成员指针值。 [§2.14.7]

Answer 4

模板参数推导是模式匹配。除了转换为基础之外，它不会对参数进行太多转换（嗯，在类型和decay 上添加const 和引用限定符）。

虽然nullptr 可以转换为C< D, A >*，但它不是这样的类型。并且两个论点都平等地参与了推论。

您可以使用typename std::identity<C< D, A > >::type* 之类的东西来阻止对第二个参数的推导，第一个参数也是如此。如果对两个参数都这样做，则不会推导出 template 类型。

另一种方法是取两种任意类型，然后使用SFINAE确保一种类型的指针可以转换为另一种类型，并且可以从另一种类型转换为的一种可以推导出为@ 987654327@ 用于某些 template C 和类型 D 和 A。这可能与您对函数类型推导应该做什么的内部心理模型相匹配。但是，结果会非常非常冗长。

更好的方法可能是询问“您希望对这两个参数做什么”，然后对其进行鸭式测试，而不是进行类型匹配。

Answer 5

这是为了防止您创建一个以 nullptr 作为参数的模板。 你很可能不希望那样。您希望模板使用 propper 类作为参数，并将 nullptr 作为该参数的值。

你可以

• 显式调用正确版本的模板
• 将 nullptr 转换为模板的属性类型。
• 创建一个正确指针类型的本地变量，为其赋值 nullptr 并使用该变量进行调用。