Bonjour, cher lecteur!

Cet article est le premier d'une série d'articles abstraits que j'écrirai en lisant le livre de Scott Meyers, Effective and Modern c ++. Chacun de ces articles aura un répertoire distinct dans un projet spécialement mis en place sur github.com avec des exemples d'utilisation des fonctionnalités et techniques décrites.

Inférence de type de modèle

Une conception réussie, c'est lorsque le consommateur ne sait pas comment fonctionne l'appareil, mais que tout lui convient.

La conclusion du type de modèle est lorsqu'il existe une fonction de modèle, par exemple, et qu'elle est appelée sans modèle ni parenthèses angulaires. En même temps, le compilateur devine quel type il devra utiliser dans un objet particulier de la fonction.

Meyers divise le type - "T" , qui est affiché et le type - "ParamType" , qui est prescrit par le programmeur dans la définition du paramètre.

1. Vue des paramètres - lien ou pointeur

Afin de comprendre rapidement la règle de dérivation, je vais la refléter sous la forme d'un modèle:

type d'entrée -> type, paramètre -> type de sortie [, type final de paramètre ]

Exemple avec un lien:

template<typename T> //   T void func(T& param) //   - T& int x = 0; //   int func(x); 

Lorsque le type T est dérivé, la référentialité (*, &) est rejetée car elle est déjà indiquée lors de la définition de la fonction, comme si cela signifie "vous passez quoi que ce soit là, nous supposerons que ce n'est pas un lien, car la référentialité est déjà ajoutée sur le lieu de consommation - dans notre fonction f "

Selon le même principe, la constance est ignorée si elle est spécifiée dans le paramètre de fonction. Sur les liens, pointeurs, constance, pour ainsi dire, un masque exclusif est imposé.

Schéma de retrait

 //   int —> (T & param) —> int; const int —> (T & param) —> const int; const int & —> (T & param) —> const int //   int —> (const T & param) —> int; const int —> (const T & param) —> int; const int & —> (const T & param) —> int; //   int * —> (T * param) —> int; const int —> (T * param) —> const int; const int * —> (T * param) —> const int; //   int * —> (const T * param) —> int; const int —> (const T * param) —> int; const int * —> (const T * param) —> int; 

2. Type d'argument - référence universelle

Scott mentionne que les liens universels seront examinés plus tard, donc les règles pour les paramètres qu'il divise ici en rvalue et lvalue doivent juste être rappelées avec peu de réflexion.

 template<typename T> void func(const T&& param) 

Règles d'inférence pour lvalue

Selon Scott, c'est le seul cas où T est sorti comme référence.
Dans les exemples suivants, le type du paramètre dans la description de la fonction est une référence lvalue universelle . On peut voir que T est affiché sous forme de lien ou de lien constant, selon
à partir de l'argument d'entrée, le type du paramètre param lui-même est également une référence dans ce cas.

 lvalue int —> (T &&param) —> int &, param - int& lvalue const int —> (T &&param) —> const int &, param - const int& lvalue const int & —> (T &&param) —> const int &, param - const int& 

Le type du paramètre lui-même est également remplacé. Je pense que cela est dû au fait que le langage ne peut pas considérer une variable de valeur allouée quelque part au-dessus de celle qui peut être déplacée plus loin. Nous le découvrirons plus tard lorsque nous arriverons aux liens universels.
Pour vérifier que T est vraiment un type de référence, j'ai écrit T myVar dans le corps de la fonction de modèle, que ce T a à la fois affiché et a attendu un message - "déclaré comme référence mais non initialisé" - le lien :)

Règles d'inférence pour rvalue

Les règles «normales» du paragraphe 1 s'appliquent.

 rvalue int —> (T &&param) —> int, param - int&& 

Il est déjà évident que les références universelles ne sont «incluses» que pour les objets temporaires rvalue, dans d'autres cas, lorsque l'argument n'est pas une référence universelle, rvalue, lvalue n'est pas distingué

3. Passez par valeur (tel quel)

Lors du passage par valeur, la constance et la référentialité de l'argument d'origine sont rejetées comme inutiles car ce sont des objets indépendants complètement nouveaux, pourquoi ont-ils besoin de qualificatifs avec lesquels ils ne sont pas connectés?

 int —> (T param) —> int const int —> (T param) —> int const int & —> (T param) —> int //       ,     const char * const —> (T param) —> const char * 

Je suppose que d'autres combinaisons folles et illogiques provoqueront des erreurs de compilation, presque toujours, il s'avère, le travail du compilateur est compréhensible, vous n'avez besoin d'écouter ces explications qu'une seule fois.