明確選擇應使用哪個模板重載

Question

我們可以選擇在這種情況下應該使用哪個函數模板重載？

struct X { };

struct A { A(X){} };
struct B { B(X){} };

template<class T>
void fun(T, A) { }

template<class T>
void fun(T, B) { }

int main() {
    /* explicitly choose overload */ fun(1, X());
}

錯誤：

error: call of overloaded 'fun(int, X)' is ambiguous
     /* explicitly choose overload */ fun(1, X());
                                                ^
    candidate: void fun(T, A) [with T = int]
 void fun(T, A) { }
      ^~~
    candidate: void fun(T, B) [with T = int]
 void fun(T, B) { }
      ^~~

對於正常功能，它看起來像這樣：

void fun(A){}
void fun(B){}

int main() {
    ((void(*)(A))(fun))(X());
}

可能嗎？

Answer 1

改善你的榜樣，你可以嘗試

 ((void(*)(int, A))(fun))(1, X());

Answer 2

如果您選擇不顯式指定第一個參數類型但仍希望指定第二個參數類型，則可以使用專用於轉換目的的lambda（c ++ 14解決方案）：

struct X { };

struct A { A(X){} };
struct B { B(X){} };

template<class T>
void fun(T, A) { }

template<class T>
void fun(T, B) { }

int main() {
    [](auto v, auto x){ static_cast<void(*)(decltype(v), A)>(fun)(v, x); }(1, X());
}

[現場演示]

Answer 3

解決這個問題的一個低技術解決方案是添加一個額外的間接級別。 添加一個像funA這樣的函數，其唯一目的是為第一個版本的fun提供一個明確的名稱：

struct X { };

struct A { A(X){} };
struct B { B(X){} };

template<class T>
void fun(T, A) { }

template<class T>
void fun(T, B) { }

template <class T>
void funA(T t, A a) { fun(t, a); }

int main() {
    /* explicitly choose overload */ funA(1, X());
}

但是，我想知道為什么你不能只將參數改為A(X()) 。 無論如何你必須改變調用代碼，那么問題是什么？