Pourquoi erreur de compilation avec enable_if

Pourquoi cela ne compile pas avec gcc48 et clang32?

#include <type_traits>

template <int N> 
struct S {

    template<class T> 
    typename std::enable_if<N==1, int>::type
    f(T t) {return 1;};

    template<class T> 
    typename std::enable_if<N!=1, int>::type
    f(T t) {return 2;};
};

int main() {
    S<1> s1;
    return s1.f(99);
}

GCC erreur:

/home/lvv/p/sto/test/t.cc:12:2: error: no type named ‘type’ in ‘struct enable_if<false, int>’
  f(T t) {return 2;};
  ^

CLANG erreur:

/home/lvv/p/sto/test/t.cc:11:26: error: no type named 'type' in 'std::enable_if<false, int>'; 'enable_if' cannot be used to
      disable this declaration
        typename std::enable_if<N!=1, int>::type
                                ^~~~
/home/lvv/p/sto/test/t.cc:16:7: note: in instantiation of template class 'S<1>' requested here
        S<1> s1;
             ^

EDIT - SOLUTION

J'ai accepté la réponse de Charles de la Salvia, mais pour des raisons pratiques, je n'ai pas été en mesure d'utiliser la solution de contournement qui a été proposé (se spécialisent sur N). J'ai trouvé d'autres solution qui fonctionne pour moi. Faire enable_if dépendent T:

typename std::enable_if<(sizeof(T),N==1), int>::type
  • Êtes-vous sûr que cela va fonctionner, de toute façon? Vous ne pouvez pas surcharger les méthodes par leur type de retour (sauf si enable_if est mis en œuvre comme une construction du langage plutôt que par, que je suis actuellement en supposant, une simple basé sur un modèle de classe).
  • Pourquoi la solution de faire enable_if dépendent de T nécessaire, exactement?
  • La solution ne fonctionne pas pour moi! J'ai eu error: no matching function for call ...
  • Ma Solution? C'est pourquoi vous downvoted la question? Je posais une question ici. Pour les réponses regarder ci-dessous.
  • Le sizeof(T) ne fonctionne pas dans mon cas. Désolé pour le downvote. J'étais juste frustrés alors. J'ai utilisé le modèle par défaut de l'argument en C++11.
InformationsquelleAutor Leonid Volnitsky | 2012-12-20
  1. 19

    Parce que vous utilisez enable_if sans utiliser le paramètre de modèle T dans vos modèles de fonction. Si vous voulez vous spécialiser pour quand la struct S a un certain nombre de modèles de valeur de paramètre N, vous aurez besoin d'utiliser la classe template de la spécialisation.

    template <int N, class Enable = void> 
struct S {  };

template <int N>
struct S<N, typename std::enable_if<N == 1>::type>
{
  ....
};
    InformationsquelleAutor Charles Salvia
  2. 10

    Bien, je ne suis pas sûr de ce que tu voulais faire, mais peut-être que ce code va vous aider:

    #include <iostream>

template <int N>
struct S {

    template<class T=int>
    typename std::enable_if<N==1, T>::type
    f(T t) {return 1;}

    template<class T=int>
    typename std::enable_if<N!=1, T>::type
    f(T t) {return 2;}
};

int main()
{
    S<1> s1;
    S<2> s2;
    std::cout << s1.f(99) << " " << std::endl << s2.f(5);
}

    Cette affiche 1 et 2.

    InformationsquelleAutor foxfireee
  3. 8

    Utiliser un booléen par défaut paramètre du modèle, comme ceci:

    template <int N> 
struct S {

    template<class T, bool EnableBool=true> 
    typename std::enable_if<N==1 && EnableBool, int>::type
    f(T t) {return 1;};

    template<class T, bool EnableBool=true> 
    typename std::enable_if<N!=1 && EnableBool, int>::type
    f(T t) {return 2;};
};
    InformationsquelleAutor Paul Fultz II
  4. 6

    Pour obtenir std::enable_if à travailler comme ça, vous êtes en s'appuyant sur SFINAE. Malheureusement, au moment où vous déclarez

    S<1> s1;

    il va instancier tous S<1>'s déclarations de membre. SFINAE n'entrera en jeu à ce point si S<1> ont été mal formé construire. Il n'est pas. Malheureusement, il contient une fonction qui n'est pas valide, donc l'instanciation de S<> est pas valide.

    Pour des choses comme ça, je pourrais en remettre à un autre modèle de structure:

    template <bool B>
struct f_functor {
    template <typename T>
    static int f(T t) { return 1; }
};

template <>
struct f_functor<false> {
    template <typename T>
    static int f(T t) { return 2; }
};

template <int N> 
struct S {

    template<class T> 
    typename int f(T t) { return f_functor<N==1>::f(t); }
};
    InformationsquelleAutor Anthony
  5. 1

    Pour ce cas, vous pourriez penser à ne pas utiliser enable_if à tous. Il est possible de simplement se spécialiser f:

    template <int N> 
struct S {
    template<class T> int f(T t);
};

template<int N>
template<class T>
int S<N>::f(T t) { return 2; }

template<>
template<class T>
int S<1>::f(T t) { return 1; }

int main() {
    S<1> s1;
    return s1.f(99);
}
    InformationsquelleAutor Jan Herrmann