¿Cuándo un compilador puede inferir un parámetro de plantilla?

Question

veces, a veces no funciona:

template <class T> 
void f(T t) {} 

template <class T> 
class MyClass { 
public: 
    MyClass(T t) {} 
}; 

void test() { 
    f<int>(5); 
    MyClass<int> mc(5); 
    f(5); 
    MyClass mc(5); // this doesn't work 
} 

¿Hay una manera de cortar alrededor del ejemplo anterior? Es decir. obligar al compilador a deducir el parámetro de plantilla del parámetro constructor.

¿Esto se solucionará en el futuro, o hay una buena razón para no hacerlo?

¿Cuál es la regla general cuando el compilador puede inferir un parámetro de plantilla?

Answer 1

parámetros de plantilla pueden ser inferidas de plantillas de función cuando el tipo de parámetro se puede deducir de la plantilla parámetros

Por lo tanto, se puede inferir aquí:

template <typename T> 
void f(T t); 

template <typename T> 
void f(std::vector<T> v); 

pero no aquí:

template <typename T> 
T f() { 
    return T(); 
} 

Y no en plantillas de clase.

Así que la solución a su problema habitual es crear una función de contenedor, similar a la función de la biblioteca estándar std::make_pair:

template <class T> 
    class MyClass { 
    public: 
     MyClass(T t) {} 
     void print(){ 
      std::cout<<"try MyClass"<<std::endl; 
     } 
    }; 

    template <typename T> 
    MyClass<T> MakeMyClass(T t) { return MyClass<T>(t); } 

y luego llamar auto a = MakeMyClass(5); para crear instancias de la clase.

Answer 2

Lectura en Template Argument Deduction (y ADL or Koenig lookup).