Spécialisation de modèles pour enum

Question

Est-il possible de spécialiser une méthode basée sur un modèle pour les énumérations?

Quelque chose comme (le code non valide ci-dessous):

template <typename T>
void f(T value);

template <>
void f<enum T>(T value);

Si ce n’est pas possible, supposons que j’ai des spécialisations pour un certain nombre de types, comme int, unsigned int, long long, unsigned long long, etc., quelles sont les spécialisations qu’une valeur d’énum utilisera ?

Answer 1

Vous pouvez utiliser std::enable_if avec std::is_enum de <type_traits> pour ce faire.

En réponse à une de mes questions , litb a publié une très explication détaillée et bien écrite sur la manière de procéder grâce aux équivalents Boost.

Answer 2

Je ne suis pas sûr de bien comprendre votre question, mais vous pouvez instancier le modèle pour des énumérations spécifiques:

template <typename T>
void f(T value);

enum cars { ford, volvo, saab, subaru, toyota };
enum colors { red, black, green, blue };

template <>
void f<cars>(cars) { }

template <>
void f<colors>(colors) { }

int main() {
    f(ford);
    f(red);
}

Answer 3

Vraisemblablement, la seule chose intéressante que vous puissiez faire avec un type dont ils ne savent que le savoir, c’est qu’il est une énumération, qu’il est jeté à son type sous-jacent et qu’il fonctionne sur celui-ci. Voici comment cela pourrait ressembler, en utilisant l'approche suggérée par James (AKA SFINAE ) :

void Bar(int b); // and/or other underlying types

template<typename T>
typename std::enable_if<std::is_enum<T>::value, void>::type
Foo(T enm)
{
    Bar(static_cast<typename std::underlying_type<T>::type>(enm));
}

En bonus, voici une méthode similaire qui ne serait résolue que pour un type spécifique de votre choix (remplacez bool par is_same par le type de votre choix):

template<typename T>
typename std::enable_if<std::is_same<T,bool>::value, void>::type
Baz(T bl)
{
    if (bl)
    {
        //...
    }
    else
    {
        //...
    }
}