¿Por qué ptr_fun encuentra esto ambiguo incluso cuando se dan los parámetros de la plantilla?

Question

Por lo tanto, he aquí algo de código básico que ilustra mi pregunta:

#include <functional> 

int func(int x) { 
    return x; 
} 

int func(int x, int y) { 
    return x + y; 
} 

int main() { 
    std::ptr_fun<int, int>(func); 
} 

Tenemos 2 sobrecargas para una función con un número diferente de parámetros. Luego intento convertir la versión de un solo parámetro en un funtor. Por supuesto, estoy reunido con el siguiente error:

 
test.cc: In function 'int main()': 
test.cc:13:29: error: call of overloaded 'ptr_fun()' is ambiguous 
/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.2/include/g++-v4/bits/stl_function.h:437:5: note: candidates are: std::pointer_to_unary_function std::ptr_fun(_Result (*)(_Arg)) [with _Arg = int, _Result = int] 
/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.2/include/g++-v4/bits/stl_function.h:463:5: note:     std::pointer_to_binary_function std::ptr_fun(_Result (*)(_Arg1, _Arg2)) [with _Arg1 = int, _Arg2 = int, _Result = int] 

Sé que sólo pudiera emitir func y hacerse con él, pero me hizo pensar por qué es esto ambigua? Ninguna versión de std::ptr_fun tiene parámetros por defecto en las definiciones de plantilla, y he dicho explícitamente que los dos parámetros de plantilla son int.

De hecho, si yo sólo hago lo que el compilador está haciendo esencialmente durante el tiempo de creación de instancias de plantilla como esta:

#include <functional> 

int func(int x) { 
    return x; 
} 

int func(int x, int y) { 
    return x + y; 
} 

std::pointer_to_unary_function<int,int> my_ptr_fun (int (*f)(int)) { 
    return std::pointer_to_unary_function<int,int>(f); 
} 

int main() { 
    my_ptr_fun(func); 
}  

compila bien, de alguna manera la ambigüedad se ha ido! ¿Alguien tiene alguna duda sobre por qué este es el caso?

Answer 1

Es porque cuando llamas a una función de plantilla, no tienes que especificar ningún parámetro de plantilla que pueda inferirse por el tipo de los argumentos de la función. Como resultado, al llamar al std::ptr_fun<int, int> no se especifica cuál de las std::ptr_fun sobrecarga su llamada, y se basa en la función que pasa como argumento para la resolución. Como su func tiene sobrecargas que se ajustan a ambas sobrecargas std::ptr_fun, existe ambigüedad.

Editar: Aquí hay un ejemplo para demostrar mi point-ran en Ideone, muestra que ambas llamadas a funciones devuelven el mismo tipo.

#include <functional> 
#include <iostream> 
#include <typeinfo> 

double func(int x) 
{ 
    return x; 
} 

int main() 
{ 
    std::cout << typeid(std::ptr_fun<int>(func)).name() << std::endl; 
    std::cout << typeid(std::ptr_fun<int, double>(func)).name() << std::endl; 
}