5

下面是一个非常简短的例子。

#include <utility>

template<typename T, typename = void>
struct A {};

template<typename T, typename U>
void f(A<std::pair<T,U>>) {}

template<typename U>
void f(A<std::pair<int,U>, std::enable_if_t<std::is_same_v<int,U>>>) {}

int main() {
  A<std::pair<int, int>> x;
  f(x);
}

错误很清楚

uffa.cpp: In function ‘int main()’:                                                                                                                                                                                                                           
uffa.cpp:22:4: error: call of overloaded ‘f(A<std::pair<int, int> >&)’ is ambiguous                                                                                                                                                                           
   22 |   f(x);                                                                                                                                                                                                                                                
      |   ~^~~                                                                                                                                                                                                                                                 
uffa.cpp:10:6: note: candidate: ‘void f(A<std::pair<_T1, _T2> >) [with T = int; U = int]’                                                                                                                                                                     
   10 | void f(A<std::pair<T,U>>) {}                                                                                                                                                                                                                           
      |      ^                                                                                                                                                                                                                                                 
uffa.cpp:18:6: note: candidate: ‘void f(A<std::pair<int, U>, typename std::enable_if<is_same_v<int, U>, void>::type>) [with U = int; typename std::enable_if<is_same_v<int, U>, void>::type = void]’                                                          
   18 | void f(A<std::pair<int,U>, std::enable_if_t<std::is_same_v<int,U>>>) {}                                                                                                                                                                                
      |      ^

但我不明白为什么int在第二个重载中作为固定模板参数并不能使它更专业。毕竟，如果我, std::enable_if_t<std::is_same_v<int,U>>从中删除，那么它是首选。

4

1 回答 1

1

尽管这是，但我将提供一个外行的解释。

是的，第二个重载修复了pairas的第一个参数int，而第一个没有。

但是，另一方面，第一个重载修复了as的第二个参数Avoid，而第二个没有。

您的功能等同于：

template <typename T, typename U>
void f(A<std::pair<T, U>, void>) {}

template <typename U>
void f(A<std::pair<int,U>, blah-blah<U>>) {}

所以没有一个比另一个更专业。

如果您使用更多传统的 SFINAE，该代码将起作用：

template<typename U, std::enable_if_t<std::is_same_v<U, int>, std::nullptr_t> = nullptr>
void f(A<std::pair<int,U>>) {}

或 C++20 概念：

template <std::same_as<int> U>
void f(A<std::pair<int,U>>) {}
于 2021-06-05T10:24:37.710 回答