Wenn ein Compiler auf einen Template-Parameter schließen kann?

Question

Manchmal funktioniert es manchmal nicht:

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 
} 

Gibt es eine Möglichkeit oben um das Beispiel zu hacken? I.e. Erzwinge dem Compiler, den Template-Parameter aus dem Konstruktorparameter abzuleiten.

Wird dies in der Zukunft behoben werden, oder gibt es einen guten Grund nicht zu?

Was ist die allgemeine Regel, wenn der Compiler Template-Parameter ableiten kann?

Answer 1

Template-Parameter können

es kann also geschlossen werden hier geschlossen für werden können Parameter aus der Vorlage Funktionsschablonen wenn der Parametertyp abgeleitet werden:

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

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

aber nicht hier:

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

Und nicht in Klassenvorlagen.

Also die übliche Lösung für Ihr Problem ist es, eine Wrapper-Funktion, ähnlich wie die Standardbibliothek Funktion std::make_pair zu erstellen:

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); } 

und dann auto a = MakeMyClass(5); die Klasse zu instanziiert nennen.

Answer 2

Gelesen auf Template Argument Deduction (und ADL or Koenig lookup).