Comment fonctionne la notation « points de suspension » (...) dans les modèles variadiques et quels sont ses différents rôles dans l'emballage et le déballage des arguments ?

Modèles variadiques : dévoiler les mystères des points de suspension

Les modèles variadiques, introduits dans C 11, étendent les capacités des modèles en autorisant des fonctions et classes pour accepter et traiter un nombre variable d’arguments. Cependant, certains aspects de leur syntaxe peuvent éveiller la curiosité. L'une de ces énigmes est la notation énigmatique « points de suspension » (...), qui soulève des questions sur son objectif et son utilisation.

Dans le contexte des modèles variadiques, les points de suspension (...) servent d'outil critique pour les arguments et paramètres de packing ou de unpacking. Son rôle est déterminé par sa position relative dans la définition ou l'appel du modèle.

Déballage : expansion des paramètres en arguments

Lorsqu'elles sont placées à droite d'une expression, les points de suspension fait office de déballeur. Il permet l'expansion des paramètres du modèle en une séquence d'arguments réels. Par exemple, dans le modèle de fonction suivant :

<code class="cpp">template<class T, class... Args>
unique_ptr<T> make_unique(Args&&... args) {
    return unique_ptr<T>(new T(std::forward<Args>(args)...));
}</code>

Les points de suspension dans std::forward(args)... décompresse le paramètre du modèle Args dans la liste d'arguments de la fonction args, permettant la construction de un nouveau unique_ptr avec les arguments fournis.

Emballage : combiner des arguments dans un paramètre

À l'inverse, lorsqu'elles sont placées à gauche d'un paramètre, les points de suspension fonctionnent comme un emballeur. Il regroupe une séquence d’arguments dans un seul paramètre. Cet emballage se produit à la fois lors de la déduction des arguments du modèle et de l'invocation de l'appel de fonction.

À titre d'illustration, considérons l'appel de fonction suivant :

<code class="cpp">make_unique<int>(1, 2, 3);</code>

Les points de suspension dans make_unique(... ) packs les arguments 1, 2 et 3 dans un seul pack de paramètres, correspondant au paramètre de modèle Args.

L'exemple de fonction de modèle f démontre la capacité de compression et de décompression :

<code class="cpp">template <typename ...T>
void f(T ...args) {
    g(args...);  // Unpacking: Pattern = args
    h(x(args)...);  // Unpacking: Pattern = x(args)
    m(y(args...)...);  // Packing: Pattern = args (arg to y())
}</code>

Lors de l'appel f avec T comme {int, char, short}, chaque appel de fonction se développe comme :

<code class="cpp">g(arg0, arg1, arg2);           
h(x(arg0), x(arg1), x(arg2));
m(y(arg0, arg1, arg2));</code>

Incohérences de placement

Vous remarquerez peut-être une incohérence apparente dans le placement des points de suspension entre la liste d'arguments du modèle et la liste des paramètres de fonction. Dans l’argument du modèle, il apparaît au milieu du pack de paramètres, tandis que dans le paramètre de la fonction, il apparaît à la fin. Cette différence vient du fait que dans l'argument template, les points de suspension sont un sucre syntaxique représentant le déballage d'un pack de paramètres, tandis que dans le paramètre fonction, c'est une partie de la syntaxe qui définit le type de l'argument emballé.

En résumé, les points de suspension (...) dans les modèles variadiques jouent un rôle central dans l'expansion des paramètres en arguments et la combinaison d'arguments en paramètres, permettant la création d'un code flexible et extensible capable de gérer un nombre variable d'arguments.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!