Que sont les guides de déduction de gabarit et quand devrions-nous les utiliser?

Question

La norme C ++ 17 introduit les "guides de déduction de modèles". Je suppose qu'ils ont quelque chose à voir avec la nouvelle déduction d'argument de modèle pour les constructeurs introduite dans cette version de la norme, mais je n'ai pas encore vu d'explication simple, de type FAQ, de ce qu'ils sont et à quoi ils servent.

• Que sont les guides de déduction de gabarit en C ++ 17?

• Pourquoi (et quand) en avons-nous besoin?

• Comment puis-je les déclarer?

Answer 1

Modèle de déduction des guides sont des modèles associés à un modèle de classe que de dire au compilateur comment traduire un ensemble de paramètres et leurs types) dans les arguments de modèle.

L'exemple le plus simple est celui de l' std::vector et de son constructeur qui prend un itérateur paire.

template<typename Iterator>
void func(Iterator first, Iterator last)
{
  vector v(first, last);
}

Le compilateur a besoin de comprendre à quel vector<T>s' T type sera. Nous savons que la réponse est: T devrait être typename std::iterator_traits<Iterator>::value_type. Mais comment pouvons-nous dire au compilateur sans avoir à taper vector<typename std::iterator_traits<Iterator>::value_type>?

Vous utilisez une déduction guide:

template<typename Iterator> vector(Iterator b, Iterator e) -> 
    vector<typename std::iterator_traits<Iterator>::value_type>;

Elle indique au compilateur que, lorsque vous appelez un vector constructeur correspondant à ce modèle, il en déduira l' vector spécialisation en utilisant le code sur le droit d' ->.

Vous avez besoin de guides lors de la déduction du type de l'argumentation n'est pas fondée sur le type de ces arguments. L'initialisation de l' vector d'un initializer_list utilise explicitement l' vectors' T, de sorte qu'il n'a pas besoin d'un guide.

Le côté gauche n'est pas nécessairement spécifier un constructeur. La façon dont cela fonctionne est que, si vous utilisez le modèle de constructeur déduction sur un type, il correspond à des arguments que vous avez passer à l'encontre de tous déduction des guides (réelle constructeurs de la primaire modèle de fournir implicite guides). Si il y a un match, il l'utilise pour déterminer le modèle d'arguments à fournir le type.

Mais une fois que la déduction est fait, une fois que le compilateur détermine les paramètres du modèle pour le type, l'initialisation de l'objet de ce type de produit, comme si rien de tout ce qui s'est passé. Qui est, la déduction guide n'a pas choisi de faire correspondre le constructeur sélectionné.

Cela signifie également que vous pouvez utiliser des guides avec des agrégats et granulats d'initialisation:

template<typename T>
struct Thingy
{
  T t;
};

Thingy(const char *) -> Thingy<std::string>;

Thingy thing{"A String"}; //thing.t is a `std::string`.

Donc déduction des guides sont uniquement utilisées pour déterminer le type de cours d'initialisation. Le processus réel de l'initialisation fonctionne exactement comme avant, une fois que la décision a été prise.