Lorsqu'un compilateur peut déduire un paramètre de modèle?

Question

Parfois, il fonctionne parfois:

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 
} 

est-il un moyen de pirater autour de l'exemple ci-dessus? C'est à dire. forcez le compilateur à déduire le paramètre de modèle du paramètre constructeur.

Cela sera-t-il corrigé à l'avenir ou y a-t-il une bonne raison de ne pas le faire?

Quelle est la règle générale lorsque le compilateur peut déduire un paramètre de modèle?

Answer 1

paramètres du modèle peuvent être inférées pour modèles de fonction lorsque le type de paramètre peut être déduit à partir des paramètres modèle

On peut donc conclure ici:

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

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

mais pas ici:

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

Et non dans modèles de classe.

Donc, la solution habituelle à votre problème est de créer une fonction enveloppe, similaire à la fonction de la bibliothèque standard 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); } 

puis appelez auto a = MakeMyClass(5); instancier la classe.

Answer 2

Lire sur Template Argument Deduction (et ADL or Koenig lookup).