C++；函数模板重载：空大括号vs显式int 下面有一些非常简单的C++函数模板重载解析实例（从实际代码中最小化）结构{ S（）{} S（int）{} }; 模板 void foo（tx）{std:：cout_C++_C++20_Function Templates Overloading

C++；函数模板重载：空大括号vs显式int 下面有一些非常简单的C++函数模板重载解析实例（从实际代码中最小化）结构{ S（）{} S（int）{} }; 模板 void foo（tx）{std:：cout

c++

C++；函数模板重载：空大括号vs显式int 下面有一些非常简单的C++函数模板重载解析实例（从实际代码中最小化）结构{ S（）{} S（int）{} }; 模板 void foo（tx）{std:：cout,c++,c++20,function-templates-overloading,C++,C++20,Function Templates Overloading,只有一个候选参与重载解析：模板void foo（T）；函数模板专门化的选择随后进行。在这种情况下，我们有： foo（{}）无法推断t（因为{}没有类型），因此我们转而使用t的默认参数，即S。这为我们提供了一个可行的调用-foo的候选者我们决定调用 FoO 之后，我们考虑专门化。有一个，所以选择它。 foo（0）可以推断出T，T是int。这给了我们一个可行的候选者来调用-foo。这没有专门化，这个[误导性地]打印“S”（即使这里没有涉及S）默认模板参数仅在无法推导或未显式提供实际

只有一个候选参与重载解析：

模板void foo（T）；

函数模板专门化的选择随后进行。在这种情况下，我们有：

```
foo（{}）
```
无法推断
```
t
```
（因为
```
{}
```
没有类型），因此我们转而使用
```
t
```
的默认参数，即
```
S
```
。这为我们提供了一个可行的调用-
```
foo
```
的候选者

我们决定调用<代码> FoO 之后，我们考虑专门化。有一个，所以选择它。
```
foo（0）
```
可以推断出
```
T
```
，
```
T
```
是
```
int
```
。这给了我们一个可行的候选者来调用-
```
foo
```
。这没有专门化，这个[误导性地]打印
```
“S”
```
（即使这里没有涉及
```
S
```
）

默认模板参数仅在无法推导或未显式提供实际模板参数时起作用

如果你想要甚至

foo（0）

要调用

foo

，您需要防止演绎成功地拾取

int

。但是在这一点上，为什么要有一个模板，只需要一个函数，它接受

，编译器将使用尽可能少的转换。

foo

，其中

T=int

，是

的完美匹配，所以这就是编译器选择的对象，而不是选择

foo

并从

构造一个临时

对象。

struct S {
    S() {}
    S(int) {}
};

template <typename T = S>
void foo(T x) { std::cout << "S" << std::endl; }

template <>
void foo<S>(S x) { std::cout << "S spc" << std::endl; }

int main() {
    foo({});
    foo(0);
}