Comment vérifier le type d'un paramètre de modèle?

Supposons que j'ai une fonction de modèle et de deux classes de

class animal {
}
class person {
}

template<class T>
void foo() {
  if (T is animal) {
    kill();
  }
}

Comment puis-je faire le check pour T est un animal? Je ne veux pas avoir
quelque chose qui vérifie pendant le temps d'exécution. Grâce

  • Je mettrais "animal de compagnie" au lieu de "tuer" 🙂
InformationsquelleAutor WhatABeautifulWorld | 2012-11-29
  1. 86

    Utilisation is_same:

    #include <type_traits>

template <typename T>
void foo()
{
    if (std::is_same<T, animal>::value) { /* ... */ }  //optimizable...
}

    Généralement, c'est totalement impraticable conception, cependant, et vous voulez vraiment se spécialisent:

    template <typename T> void foo() { /* generic implementation  */ }

template <> void foo<animal>()   { /* specific for T = animal */ }

    Noter également qu'il est inhabituel d'avoir les modèles de fonction explicite (non déduit) arguments. Il n'est pas rare, mais il y a souvent des approches mieux.

    • TThanks! En fait, ils partagent BEAUCOUP de code donc je ne peux pas vraiment le dupliquer
    • Vous pouvez toujours tenir compte de votre code, de sorte que le type de partie dépendant peut être relégué à un specializable fonction...
    • Un suivi rapide, si je ne l'utilisation de std::is_same, alors il ne sera PAS ralentir le code pour les autres paramètres du modèle, à droite?
    • Le trait valeurs sont statiquement connu. Il n'y a aucun coût d'exécution, à condition que votre compilateur est à moitié décent. Vérifiez le montage en cas de doute, cependant.
    • Une question: si je ne veux se spécialisent le comportement de la méthode de un seul type spécifique, en utilisant C++11 par défaut paramètres du modèle de travail ainsi?
    • Depuis T n'est pas déduit, il n'y a pas beaucoup que vous pouvez faire. Vous pouvez laisser le principal modèle de lettre morte et à créer une spécialisation, ou vous pouvez ajouter un statique affirmation avec is_same.
    • Comment savoir le type de l'argument passé pour les types de données primitifs comme si l'int est passé ou le char est passé?
    • comment voulez-vous dire? La fonction foo a pas de paramètres, de sorte qu'aucun des arguments peuvent être passés. Vous devez spécifier l'argument de modèle directement. Et puis le code de la réponse de test pour int et float, trop (is_same<T, int> etc.).

    InformationsquelleAutor Kerrek SB
  2. 17

    Je pense qu'aujourd'hui, il est préférable d'utiliser, mais seulement avec le C++17.

    #include <type_traits>

template <typename T>
void foo() {
    if constexpr (std::is_same_v<T, animal>) {
        //use type specific operations... 
    } 
}

    Si vous utilisez un type spécifique d'opérations si l'expression du corps sans constexpr, ce code ne compilera pas.

    • au lieu de std::is_same<T, U>::value vous pouvez utiliser plus courte: std::is_same_v<T, U>
    • yep is_same_v, merci
    InformationsquelleAutor Константин Гудков
  3. 6

    En C++17, nous pouvons utiliser variantes.

    À utiliser std::variant, vous devez inclure l'en-tête:

    #include <variant>

    Après cela, vous pouvez ajouter std::variant dans votre code comme ceci:

    using Type = std::variant<Animal, Person>;

template <class T>
void foo(Type type) {
    if (std::is_same_v<type, Animal>) {
        //Do stuff...
    } else {
        //Do stuff...
    }
}
    • Comment sont T et le Type connecté?
    • Aïe, je l'ai corrigé
    • Cette réponse est problématique à plusieurs égards. Outre les erreurs (type qui est la valeur de type Type ou d'un modèle qui n'a pas de sens ici) is_same_v n'est pas pertinent dans le contexte de variant. Le correspondant de "trait" est holds_alternative.
    InformationsquelleAutor Edwin Pratt
  4. 5

    Vous pouvez vous spécialiser vos modèles basés sur ce qui est passé dans leur paramètres comme ceci: 

    template <> void foo<animal> {

}

    Notez que cela crée une toute nouvelle fonction, basé sur le type qui est passé comme T. C'est généralement préférable, car elle réduit l'encombrement et est essentiellement la raison pour laquelle nous avons des modèles à la première place.

    • Hmm. Cette méthode est-elle vraiment la seule façon préférable de se spécialiser argument de modèle? Disons que j'ai 10 différentes classes enfant que j'ai besoin de gérer à l'intérieur de la fonction de modèle. Dois-je vraiment écrire 10 différents modèles de fonctions pour chaque classe? Je pense que j'ai peut-être manquant le point central ici.
    • Cela sonne vraiment comme une bonne idée, si quelqu'un ne veut pas l'utiliser type_traits. Comme quelqu'un l'a dit l'essentiel de la logique peut être fait dans une autre fonction, qui accepte un indicateur supplémentaire pour indiquer le type, et cette déclaration pouvez simplement mettre le drapeau en conséquence et directement passer sur tous les autres arguments sans rien toucher. Donc, si 10 classes différentes doivent être traitées, c'est essentiellement à 10 lignes de 10 différentes définitions de fonction. Mais cela va obtenir beaucoup compliqué s'il y a plus de 1 variable de modèle.
    InformationsquelleAutor template boy