web-dev-qa-db-fra.com

C++ 11: Spécialisation de fonction de modèle pour les types entiers

Supposons que j'ai une fonction template:

template<typename T>
void f(T t)
{
    ...
}

et je veux écrire une spécialisation pour tous les types entiers primitifs. Quelle est la meilleure façon de procéder?

Ce que je veux dire est:

template<typename I where is_integral<I>::value is true>
void f(I i)
{
    ...
}

et le compilateur sélectionne la deuxième version pour les types entiers et la première version pour tout le reste?

c++templatesc++11
28
Andrew Tomazos

Utilisez SFINAE

// For all types except integral types:
template<typename T>
typename std::enable_if<!std::is_integral<T>::value>::type f(T t)
{
    // ...
}

// For integral types only:
template<typename T>
typename std::enable_if<std::is_integral<T>::value>::type f(T t)
{
    // ...
}

Notez que vous devrez inclure la valeur de retour complète std::enable_if même pour la déclaration.

41
David

Je voudrais utiliser la résolution de surcharge. Cela vous évite d'avoir à utiliser le piratage brut SFINAE. Malheureusement, il existe de nombreux domaines dans lesquels vous ne pouvez pas l'éviter, mais heureusement, ce n'en est pas un.

template<typename T>
void f(T t)
{
  f(t, std::is_integral<T>());
}

template<typename T>
void f(T t, std::true_type)
{ 
  // ...
}

template<typename T>
void f(T t, std::false_type)
{ 
  // ...
}
24
Johannes Schaub - litb

Std :: enable_if ( http://fr.cppreference.com/w/cpp/types/enable_if ) peut être utilisé pour cela:

template<typename T, class = typename std::enable_if<std::is_integral<T>::value>::type>
void f(T t) {...}
11
arnoo

Vous pouvez utiliser un modèle d'assistance que vous pouvez spécialiser comme ceci:

#include <string>
#include <iostream>
#include <type_traits>

template <typename T, bool = std::is_integral<T>::value>
struct Foo {
        static void bar(const T& t) { std::cout << "generic: " << t << "\n"; }
};
template <typename T>
struct Foo<T, true> {
        static void bar(const T& t) { std::cout << "integral: " << t << "\n"; }
};

template <typename T>
static void bar(const T& t) {
        return Foo<T>::bar(t);
}

int main() {
        std::string s = "string";
        bar(s);
        int i = 42;
        bar(i);
        return 0;
}

sortie:

generic: string
integral: 42
7
mitchnull

Qu'en est-il d'une manière plus simple et plus lisible simplement en implémentant les différentes versions dans le corps de la fonction?

    template<typename T>
    void DoSomething(T inVal) {
        static_assert(std::is_floating_point<T>::value || std::is_integral<T>::value, "Only defined for float or integral types");
        if constexpr(std::is_floating_point<T>::value) {
            // Do something with a float
        } else if constexpr(std::is_integral<T>::value) {
            // Do something with an integral
        }
    }

Vous n'avez pas à vous soucier de la performance. Les conditions sont des constantes de temps de compilation et un compilateur de descente les optimisera. "If constexpr" vaut c ++ 17 malheureusement, mais vous pouvez supprimer "constexpr" lorsque les deux versions sont compilées sans erreur pour les deux types

0
Ole Dittmann