Où et pourquoi dois-je mettre le “modèle” et “typename” de mots-clés?

Afin d'analyser un programme en C++, le compilateur a besoin de savoir si certains noms sont des types ou pas. L'exemple suivant montre que:

t * f;

Comment cela doit-il être interprété? Pour de nombreuses langues, le compilateur n'a pas besoin de connaître la signification d'un nom afin de les analyser et, essentiellement, de savoir ce qu'une ligne de code. En C++, le ci-dessus peut toutefois rendement très différentes interprétations en fonction de ce t moyens. Si c'est un type, alors il y aura une déclaration d'un pointeur f. Toutefois, si c'est pas un type, il sera une multiplication. De sorte que le C++ Standard dit au paragraphe (3/7):

Certains noms de désigner des types ou des modèles. En général, quand un nom est rencontré, il est nécessaire de déterminer si ce nom désigne l'une de ces entités avant de continuer à analyser le programme qu'il contient. Le processus qui détermine ce qui est appelé la recherche d'un nom.

Comment le compilateur de savoir ce qu'est un nom de t::x se réfère, si t se réfère à un modèle type de paramètre? x pourrait être un static int membre de données qui pourrait être multiplié ou pourrait tout aussi bien être une classe imbriquée ou définition de type qui pourrait produire une déclaration. Si un nom a cette propriété qu'il ne peut pas être regardé, jusqu'à ce que le modèle actuel et les arguments sont connus, alors il est appelé un dépendante nom (il "dépend" sur les paramètres du modèle).

Vous pourriez recommander à juste attendre jusqu'à ce que l'utilisateur instancie le modèle:

Nous allons attendre jusqu'à ce que l'utilisateur instancie le modèle, puis plus tard, trouver le vrai sens de la t::x * f;.

Cela fonctionne, et c'est permis par la Norme comme une possible approche de mise en œuvre. Ces compilateurs essentiellement de copier le modèle du texte dans une mémoire tampon interne, et uniquement lors d'une instanciation est nécessaire, ils analyser le modèle et éventuellement de détecter les erreurs dans la définition. Mais plutôt que de déranger le modèle des utilisateurs (les pauvres collègues!) avec les erreurs commises par un modèle de l'auteur, d'autres implémentations de choisir de vérifier les modèles de début et de lui donner les erreurs dans la définition, dès que possible, avant qu'une instanciation d'un même lieu.

Donc il y a une façon de dire au compilateur que certains noms sont des types, et que certains noms ne sont pas.

La "typename" mot-clé

La réponse est: Nous décider comment le compilateur doit analyser cette. Si t::x est une personne à charge nom, alors nous avons besoin de le préfixer par typename pour indiquer au compilateur d'analyser, d'une certaine façon. Que dit la Norme (14.6/2):

Un nom utilisé dans un modèle de déclaration ou de définition et qui dépend d'un modèle à paramètre est
en principe pas de nom, un type, à moins que le nom applicables de recherche trouve un nom de type ou le nom est qualifié
par le mot-clé typename.

Il y a beaucoup de noms pour lesquels typename n'est pas nécessaire, car le compilateur ne peut, avec la recherche d'un nom dans la définition de modèle, de comprendre comment analyser une construction elle - même, par exemple avec T *f;, quand T est un type de paramètre de modèle. Mais pour t::x * f; être une déclaration, il doit être écrit comme typename t::x *f;. Si vous omettez le mot clé et le nom est pris pour être un non-type, mais lors de l'instanciation trouve qu'il dénote un type, l'habitude de messages d'erreur émis par le compilateur. Parfois, l'erreur est donc donnée à la définition du temps:

//t::x is taken as non-type, but as an expression the following misses an
//operator between the two names or a semicolon separating them.
t::x f;

La syntaxe permet typename seulement avant les noms qualifiés - il est donc pris comme acquis que les noms non qualifiés sont toujours connus pour désigner des types s'ils le font.

Similaire gotcha existe pour les noms désignant des modèles, comme signalé par le texte d'introduction.

Le "modèle" mot-clé

Souviens de la première citation ci-dessus et comment le Standard nécessite un traitement spécial pour les modèles ainsi? Prenons la suite de l'allure innocente exemple:

boost::function< int() > f;

Ça peut paraître évident pour un lecteur humain. Pas tellement pour le compilateur. Imaginez la suite arbitraire de la définition de boost::function et f:

namespace boost { int function = 0; }
int main() { 
  int f = 0;
  boost::function< int() > f; 
}

Qui est en fait valable expression! Il utilise l'opérateur inférieur à comparer boost::function contre zéro (int()), puis utilise l'opérateur supérieur à comparer l'résultant bool contre f. Cependant comme vous pouvez vous le savez bien, boost::function dans la vraie vie est un modèle, de sorte que le compilateur sait (14.2/3):

Après la recherche du nom de (3.4) constate qu'un nom est un modèle de nom, si ce nom est suivi par un <, < est
toujours considéré comme le début d'un modèle de la liste d'arguments et jamais comme un nom suivi de la moins-que
de l'opérateur.

Maintenant nous sommes de retour pour le même problème qu'avec typename. Que faire si nous ne savons pas encore si le nom est un modèle lors de l'analyse du code? Nous aurons besoin d'insérer template immédiatement avant le nom du modèle, tel que spécifié par 14.2/4. Cela ressemble à:

t::template f<int>(); //call a function template

Les noms de modèle ne peut pas seulement se produire après un :: mais aussi après une -> ou . dans une classe de l'accès des membres. Vous devez insérer le mot-clé il y a trop:

this->template f<int>(); //call a function template

---

Dépendances

Pour les gens qui ont une épaisseur de Standardese livres sur leur étagère et qui veulent savoir exactement ce dont je parlais, je vais parler un peu comment cela est spécifié dans la Norme.

Dans le modèle des déclarations de certaines constructions ont des significations différentes en fonction de ce modèle arguments que vous utilisez pour instancier le modèle: les Expressions peuvent avoir différents types ou des valeurs, des variables peuvent avoir des types différents ou des appels de fonction pourrait appeler des fonctions différentes. De telles constructions sont généralement dépendent sur les paramètres du modèle.

La Norme définit précisément les règles de savoir si une construction est dépendante ou non. Il les sépare logiquement dans les différents groupes: l'Un des captures types, un autre des captures d'expressions. Les Expressions peuvent dépendre de leur valeur et/ou de leur type. Nous avons donc, avec des exemples typiques ajouté:

• Types de charge (e.g: un type de paramètre de modèle T)
• Valeur dépendante des expressions (e.g: non-type de paramètre de modèle N)
• En fonction du Type d'expressions (e.g: un casting pour un type de paramètre de modèle (T)0)

La plupart des règles sont intuitives et sont construits de manière récursive: Par exemple, un type construit comme T[N] est un type dépendant si N est une valeur dépendante de l'expression ou de la T est un type de charge. Les détails de ce qui peut être lu dans la section (14.6.2/1) pour les types de charge, (14.6.2.2) pour les en fonction du type d'expressions et (14.6.2.3) pour une valeur dépendante de la expressions.

Dépendant de noms

La Norme est un peu confus au sujet de ce que exactement est un dépendante nom. Sur une simple lecture (vous savez, le principe de moindre surprise), tout ce qu'il définit comme un dépendante nom est le cas spécial pour les noms de fonction ci-dessous. Mais depuis clairement T::x doit également être recherchée dans l'instanciation contexte, il a aussi besoin d'être une personne à charge nom (heureusement, au milieu de C++14, le comité a commencé à examiner la façon de résoudre cette confusion définition).

Pour éviter ce problème, j'ai recours à une simple interprétation du texte Standard. De toutes les constructions qui dénotent des types dépendants ou des expressions, un sous-ensemble d'entre eux représentent des noms. Ces noms sont donc "dépendante" de noms. Un nom peut prendre différentes formes - que dit la Norme:

Un nom est une utilisation d'un identifiant (2.11), opérateur-la fonction id (13.5), la conversion en fonction de l'id (12.3.2), ou le modèle-id (14.2) qui désigne une entité ou d'une étiquette (6.6.4, 6.1)

Un identificateur est juste une simple séquence de caractères /chiffres, tandis que les deux suivantes sont les operator + et operator type forme. La dernière forme est template-name <argument list>. Tous ces noms, et par l'utilisation conventionnelle de la Norme, un nom peut également inclure des qualificatifs que dire ce que l'espace de noms ou de classe, un nom doit être recherché dans.

Une valeur dépendante de l'expression 1 + N n'est pas un nom, mais N est. Le sous-ensemble de tous dépendants les constructions qui sont des noms est appelé dépendante nom. Les noms de fonction, cependant, peut avoir une signification différente dans les différentes instanciations d'un modèle, mais, malheureusement, ne sont pas visés par cette règle générale.

Fonction dépend de noms

Pas principalement une préoccupation de cet article, mais il vaut la peine de mentionner les noms de Fonction sont une exception qui sont traitées séparément. Un identificateur nom de la fonction est dépendante de la pas par lui-même, mais par le type dépendant argument une expression utilisée dans un appel. Dans l'exemple f((T)0), f est une personne à charge nom. Dans la Norme, c'est spécifiée à (14.6.2/1).

Des notes supplémentaires et des exemples

Assez de cas, nous avons besoin à la fois de typename et template. Votre code devrait ressembler à celui-ci

template <typename T, typename Tail>
struct UnionNode : public Tail {
    //...
    template<typename U> struct inUnion {
        typedef typename Tail::template inUnion<U> dummy;
    };
    //...
};

Le mot-clé template n'est pas toujours figurer dans la dernière partie d'un nom. Elle peut apparaître sur le milieu devant un nom de classe qui est utilisé comme un champ d'application, comme dans l'exemple suivant

typename t::template iterator<int>::value_type v;

Dans certains cas, les mots clés sont interdites, comme détaillé ci-dessous

• Sur le nom de l'un dépendant de la classe de base, vous n'êtes pas autorisé à écrire typename. Il est supposé que le nom donné est un type de classe nom. Cela est vrai pour les deux noms dans la base-liste des classes et le constructeur de l'initialiseur de la liste:

   template <typename T>
   struct derive_from_Has_type : /* typename */ SomeBase<T>::type 
   { };

• À l'aide de déclarations, il n'est pas possible d'utiliser template après la dernière ::, et le comité C++ dit de ne pas travailler sur une solution.

   template <typename T>
   struct derive_from_Has_type : SomeBase<T> {
      using SomeBase<T>::template type; //error
      using typename SomeBase<T>::type; //typename *is* allowed
   };

OriginalL'auteur Johannes Schaub - litb

PRÉFACE

Ce post est destiné à être un facile à lire alternative à litb post.

L'objectif sous-jacent est le même; une explication à la question "Quand?" et "Pourquoi?" typename et template doit être appliqué.

---

Quel est le but de typename et template?

typename et template sont utilisables dans d'autres situations que lors de la déclaration d'un modèle.

Il y a certains contextes dans C++ où le compilateur doit être explicitement dit comment traiter un nom, et tous ces contextes ont une chose en commun; ils dépendent d'au moins un template-parameter.

Nous nous référons à ces noms, où il peut y avoir une ambiguïté dans l'interprétation, comme; "dépendant de noms".

Ce poste va offrir une explication de la relation entre dépendante des noms de, et les deux mots-clés.

---

UN EXTRAIT EN DIT PLUS QUE 1000 MOTS

Essayer d'expliquer ce qui se passe dans la suite de de la fonction de modèle de, soit à vous-même, un ami, ou peut-être de votre chat, ce qui se passe dans l'énoncé marqué (Un)?

template<class T> void f_tmpl () { T::foo * x; /* <-- (A) */ }

Il pourrait ne pas être aussi facile qu'on le pense, plus précisément le résultat de l'évaluation (Un) fortement dépend sur la définition du type passé en tant que modèle à paramètre T.

Différents Ts peuvent changer radicalement la sémantique impliqués.

struct X { typedef int       foo;       }; /* (C) --> */ f_tmpl<X> ();
struct Y { static  int const foo = 123; }; /* (D) --> */ f_tmpl<Y> ();

Les deux scénarios différents:

• Si nous instancier la fonction de modèle de type X, comme dans (C), nous aurons une déclaration d'un pointeur vers int nommé x, mais;

• si nous instancier le modèle de type Y, comme dans (D), (Un) devrait plutôt consister en une expression qui calcule le produit de 123 multiplié avec certains déjà déclaré variable x.

---

LA JUSTIFICATION

La Norme C++ se soucie de la sécurité et le bien-être, au moins dans ce cas.

Pour empêcher une mise en œuvre à partir de potentiellement souffrant de mauvaises surprises, la Norme mandats que nous avons en quelque sorte l'ambiguïté d'un dépendante de nom de par explicitement indiquant l'intention de n'importe où nous aimerions traiter le nom comme un type de nom de, ou un modèle-id.

Si rien n'est indiqué, le dépendante de nom de sera considéré comme une variable ou une fonction.

---

COMMENT GÉRER DÉPENDANT DE NOMS?

Si c'était un film d'Hollywood, dépendante des noms de serait la maladie qui se propage par le contact du corps, instantanément affecte son hôte pour le rendre confus. La Confusion qui pourrait, éventuellement, conduire à un mal-formé perso-, heu.. programme.

Un dépendante de nom de est tout nom qui, directement ou indirectement, dépend d'un template-parameter.

template<class T> void g_tmpl () {
   SomeTrait<T>::type                   foo; //(E), ill-formed
   SomeTrait<T>::NestedTrait<int>::type bar; //(F), ill-formed
   foo.data<int> ();                         //(G), ill-formed    
}

Nous avons quatre dépendante noms dans l'extrait ci-dessus:

• E)
  • "type" dépend de l'instanciation de SomeTrait<T>, qui comprennent T, et;
• F)
  • "NestedTrait", qui est un modèle-id, dépend SomeTrait<T>, et;
  • "type" à la fin de l' (F) dépend NestedTrait, qui dépend de l' SomeTrait<T>, et;
• G)
  • "données", qui ressemble à une états-modèle de fonction, est indirectement un dépendante de nom de puisque le type de foo dépend de l'instanciation de SomeTrait<T>.

Ni de déclaration (E), (F) ou (G) est valide si le compilateur pourrait interpréter le dépendante des noms de comme des variables/fonctions (comme indiqué plus haut est ce qui se passe si nous n'avons pas explicitement dire le contraire).

LA SOLUTION

De faire g_tmpl ont une définition valable, nous devons indiquer explicitement au compilateur que nous nous attendons à un type (E), un modèle-id et un type (F), et un modèle-id (G).

template<class T> void g_tmpl () {
   typename SomeTrait<T>::type foo;                            //(G), legal
   typename SomeTrait<T>::template NestedTrait<int>::type bar; //(H), legal
   foo.template data<int> ();                                  //(I), legal
}

Chaque fois qu'un nom désigne un type, tous noms concernées doivent être type-noms ou espaces de noms, avec cela à l'esprit, il est assez facile de voir que l'on applique typename au début de notre nom qualifié.

template cependant, est différente à cet égard, car il n'y a aucun moyen d'en venir à une conclusion comme; "oh, c'est un modèle, puis cette autre chose doit être aussi un modèle". Cela signifie que l'on applique template directement en face de toute l' nom que nous aimerions traiter comme tel.

---

PUIS-JE SIMPLEMENT COLLER LE MOTS-CLÉS EN FACE DE SON NOM?

"Pouvez je viens de coller typename et template en face de son nom? Je ne veux pas à vous soucier du contexte dans lequel ils apparaissent..." - Some C++ Developer

Les règles de la Norme stipule que vous pouvez appliquer des mots-clés comme longtemps que vous faites affaire avec un qualifié-nom (K), mais si le nom n'est pas qualifié l'application est mal formé (L).

namespace N {
  template<class T>
  struct X { };
}

         N::         X<int> a; //...  legal
typename N::template X<int> b; //(K), legal
typename template    X<int> c; //(L), ill-formed

^{Note: Application de typename ou template dans un contexte où il n'est pas nécessaire n'est pas considéré comme une bonne pratique; juste parce que vous pouvez faire quelque chose, ne signifie pas que vous devriez.}

En outre il y a des contextes où typename et template sont explicitement interdits:

• Lors de la spécification des bases dont la classe hérite

  Chaque nom écrit dans une classe dérivée de de base-spécificateur-liste est déjà traité comme un type de nom de, spécifiant explicitement typename est à la fois mal formé, et redondants.

                     //.------- the base-specifier-list
   template<class T> //v
   struct Derived      : typename SomeTrait<T>::type /* <- ill-formed */ {
     ...
   };

• Lorsque le modèle-id est celui mentionné dans une classe dérivée de à l'aide de la directive

   struct Base {
     template<class T>
     struct type { };
   };
  
   struct Derived : Base {
     using Base::template type; //ill-formed
     using Base::type;          //legal
   };

OriginalL'auteur Filip Roséen - refp

_{Cette réponse est destinée à être assez court et doux une réponse (une partie de) l'intitulé de la question. Si vous voulez une réponse avec plus de détails qui explique pourquoi vous devez les mettre là, s'il vous plaît aller ici.}

---

La règle générale pour mettre le typename mot-clé est la plupart du temps lorsque vous utilisez un paramètre de modèle et que vous souhaitez accéder à un imbriquée typedef ou l'aide-alias, par exemple:

template<typename T>
struct test {
    using type = T; //no typename required
    using underlying_type = typename T::type //typename required
};

Noter que ceci s'applique également aux fonctions de meta ou les choses qui prennent modèle générique de paramètres. Cependant, si le paramètre de modèle fourni est de type explicite, alors vous n'avez pas à spécifier typename, par exemple:

template<typename T>
struct test {
    //typename required
    using type = typename std::conditional<true, const T&, T&&>::type;
    //no typename required
    using integer = std::conditional<true, int, float>::type;
};

Les règles générales pour l'ajout de la template qualificatif sont pour la plupart les mêmes, sauf qu'ils impliquent généralement basées sur des modèles de fonctions membres (statiques ou non) de la structure/classe qui est lui-même basé sur un modèle, par exemple:

Compte tenu de cette structure et de la fonction:

template<typename T>
struct test {
    template<typename U>
    void get() const {
        std::cout << "get\n";
    }
};

template<typename T>
void func(const test<T>& t) {
    t.get<int>(); //error
}

Tenter d'accéder à des t.get<int>() à partir de l'intérieur de la fonction génère une erreur:

main.cpp:13:11: error: expected primary-expression before 'int'
     t.get<int>();
           ^
main.cpp:13:11: error: expected ';' before 'int'

Donc, dans ce contexte, vous aurez besoin de l' template mot-clé à l'avance et de l'appeler de la sorte:

t.template get<int>()

De cette façon, le compilateur va analyser correctement, plutôt que de t.get < int.

OriginalL'auteur Rapptz