Chapitre 4 Modèle de paramètre variable: 4.3 Application du modèle de paramètre variable

4.3 Application de modèles variadiques

4.3 Application de modèles de paramètres variables

 

Les modèles Variadic jouent un rôle important lors de l'implémentation de bibliothèques génériques, telles que la bibliothèque standard C ++.

Les modèles de paramètres variables jouent un rôle très important dans l'implémentation de bibliothèques communes (telles que la bibliothèque standard C ++).

Une application typique est la transmission d'un nombre variadique d'arguments de type arbitraire.

Une application classique consiste à transmettre un nombre arbitraire de paramètres de tout type.

Par exemple, nous utilisons cette fonctionnalité lorsque:

Par exemple, nous utilisons cette fonctionnalité dans les situations suivantes:

• Passer des arguments au constructeur d'un nouvel objet tas appartenant à un pointeur partagé:

 Passez les paramètres au constructeur du nouvel objet tas appartenant à shared_ptr:

// crée un pointeur partagé vers <float> complexe initialisé par 4.2 et 7.7: 
auto sp = std :: make_shared <std :: complex < float >> ( 4.2 , 7.7 );

• Passer des arguments à un thread, qui est démarré par la bibliothèque:

  Passez les paramètres à l'objet thread démarré par la bibliothèque standard.

std :: thread t (foo, 42 , " bonjour " ); // appeler foo (42, "bonjour") dans un thread séparé

• Passer des arguments au constructeur d'un nouvel élément poussé dans un vecteur:

  Passez les paramètres au constructeur de l'élément nouvellement poussé dans le vecteur:

std :: vector <Client> v; 
… 
V.emplace ( " Tim " , " Jovi " , 1962 ); // insère un Client initialisé par trois arguments

Habituellement, les arguments sont «parfaitement transmis» avec la sémantique de déplacement (voir la section 6.1 à la page 91), de sorte que les déclarations correspondantes sont, par exemple:

Normalement, ces paramètres sont "parfaitement retransmis" via la sémantique mobile (voir la section 6.1 à la page 91), donc la déclaration correspondante est la suivante:

namespace std { 
    template <typename T, typename ... Args> shared_ptr <T> make_shared (Args && … args); 

    thread de classe {
     public : 
        template <typename F, typename ... Args>
         thread explicite (F && f, Args && … args); 
        ... 
    }; 

    template <typename T, typename Allocator = allocator <T>>
     class vector {
     public : 
        template <typename ... Args> reference emplace_back (Args && … 
            args); 
        ... 
    }; 
}

Notez également que les mêmes règles s'appliquent aux paramètres du modèle de fonction variadique qu'aux paramètres ordinaires. Par exemple, s'ils sont transmis par valeur, les arguments sont copiés et se désintègrent (par exemple, les tableaux deviennent des pointeurs), tandis que s'ils sont transmis par référence, les paramètres se réfèrent au paramètre d'origine et ne se désintègrent pas:

Notez également que les mêmes règles s'appliquent aux paramètres de modèle de fonction variable qu'aux paramètres ordinaires. Par exemple, s'il est transmis par valeur, les paramètres sont copiés et le type est dégradé (par exemple, le tableau devient un pointeur). S'il est transmis par référence, le paramètre fera référence au paramètre d'origine et le type ne dégénérera pas (décroissance).

// args sont des copies avec des types décomposés: (args est une copie des paramètres dégradés) 
template <typename ... Args> void foo (Args ... args); 

// args sont des références non décomposées à des objets passés: (les args ne sont pas dégradés, ils sont passés Dans la référence d'objet) 
template <typename… Args> void bar (Args const &… args);