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

Parfois cela fonctionne, parfois pas:

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? I. e. forcer le compilateur à déduire le paramètre de modèle de paramètre du constructeur.

Ce que ce sera corrigé dans le futur, ou est-il une bonne raison de ne pas?

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

InformationsquelleAutor | 2009-04-28
  1. 55

    Paramètres du modèle peuvent être déduites pour les modèles de fonction lorsque le type de paramètre peuvent être déduites à partir des paramètres du modèle

    De sorte qu'il peut être déduit 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 pas dans modèles de classe.

    Donc l'habituel solution à votre problème est de créer une fonction wrapper, 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); }

    et ensuite appeler auto a = MakeMyClass(5); pour instancier la classe.

    • +1, approfondie. Mineur nit: je vous suggère de changer "lorsque le paramètre type est la personne à charge" à la question "quand un type de paramètre est dépendant".
    • void f(typename T::const_iterator t); << ici, T apparaît dans un undeducible contexte. même lorsque l'appelant avec un vector<int>::const_iterator, par exemple, il ne sera pas en mesure d'en déduire vector<int> pour T. la raison en est que le sens de ::const_iterator dépend T. T à nouveau, mais dépend de la signification de ::const_iterator. c'est pourquoi boost::implicit_cast est codé comme ceci: template<typename T> T implicit_cast(typename identité<T>::type t) { return t; } ici encore, nous avons une undeducible contexte.
    • Standard-ref 14.8.2.4/4 (dernier c++1x projet est-il situé à 14.9.2.5/5 - fixation également certaines lacunes de la formulation de la norme actuelle). 🙂 cheers
    • Bah, vous avez raison, bien sûr. Ne sais pas ce que je pensais.
    • Cette réponse nécessite une mise à jour, depuis C++17 a introduit quelques nouvelles fonctionnalités pour argument de modèle déduction.
    InformationsquelleAutor jalf
  2. 8

    Lire sur Argument De Modèle Déduction (et ADL ou Koenig recherche).

    • C'est un lien unique réponse, pensez à améliorer cette réponse en fournissant les informations pertinentes à partir de matériel référencé.
    InformationsquelleAutor dirkgently
  3. 0

    En C++17, il est possible de déduire certains types à l'aide de auto, bien que les paramètres du modèle doivent encore être précisées ici:

    #include <iostream> 
#include <string>

template <class T1,class T2>   
auto print_stuff(T1 x, T2 y) 
{ 
    std::cout << x << std::endl;
    std::cout << y << std::endl;
}

int main() 
{ 
    print_stuff(3,"Hello!");
    print_stuff("Hello!",4);
    return 0; 
}

    À l'aide de la -fconcepts drapeau du ccag, il est possible de déduire les paramètres, si ce n'est pas encore une partie de la norme C++:

    #include <iostream> 
#include <string>

auto print_stuff(auto x, auto y) 
{ 
    std::cout << x << std::endl;
    std::cout << y << std::endl;
}

int main() 
{ 
    print_stuff(3,"Hello!");
    print_stuff("Hello!",4);
    return 0; 
}
    InformationsquelleAutor Anderson Green