Pourquoi devrais-je éviter std :: enable_if dans les signatures de fonction

Scott Meyers a publié le contenu et le statut de son prochain livre EC ++ 11. Il a écrit qu'un élément du livre pourrait être "Eviter std::enable_ifles signatures de fonction" .

std::enable_if peut être utilisé comme argument de fonction, comme type de retour ou comme modèle de classe ou paramètre de modèle de fonction pour supprimer conditionnellement des fonctions ou des classes de la résolution de surcharge.

Dans cette question, les trois solutions sont présentées.

En tant que paramètre de fonction:

template<typename T>
struct Check1
{
   template<typename U = T>
   U read(typename std::enable_if<
          std::is_same<U, int>::value >::type* = 0) { return 42; }

   template<typename U = T>
   U read(typename std::enable_if<
          std::is_same<U, double>::value >::type* = 0) { return 3.14; }   
};

En tant que paramètre de modèle:

template<typename T>
struct Check2
{
   template<typename U = T, typename std::enable_if<
            std::is_same<U, int>::value, int>::type = 0>
   U read() { return 42; }

   template<typename U = T, typename std::enable_if<
            std::is_same<U, double>::value, int>::type = 0>
   U read() { return 3.14; }   
};

Comme type de retour:

template<typename T>
struct Check3
{
   template<typename U = T>
   typename std::enable_if<std::is_same<U, int>::value, U>::type read() {
      return 42;
   }

   template<typename U = T>
   typename std::enable_if<std::is_same<U, double>::value, U>::type read() {
      return 3.14;
   }   
};

• Quelle solution privilégier et pourquoi éviter les autres?
• Dans quels cas "Eviter std::enable_ifdans les signatures de fonction" concerne l'utilisation comme type de retour (qui ne fait pas partie de la signature de fonction normale mais des spécialisations de modèle)?
• Existe-t-il des différences entre les modèles de fonctions membres et non membres?

Mettez le hack dans les paramètres du modèle .

L' enable_ifapproche des paramètres sur modèle présente au moins deux avantages par rapport aux autres:

• lisibilité : l'utilisation de enable_if et les types de retour / d'argument ne sont pas fusionnés en un seul morceau désordonné de désambiguïsateurs de nom de type et d'accès de type imbriqués; même si l'encombrement du désambiguïsateur et du type imbriqué peut être atténué avec des modèles d'alias, cela fusionnerait toujours deux éléments non liés ensemble. L'utilisation de enable_if est liée aux paramètres du modèle et non aux types de retour. Les avoir dans les paramètres du modèle signifie qu'ils sont plus proches de ce qui compte;

• applicabilité universelle : les constructeurs n'ont pas de types de retour, et certains opérateurs ne peuvent pas avoir d'arguments supplémentaires, donc aucune des deux autres options ne peut être appliquée partout. Mettre enable_if dans un paramètre de modèle fonctionne partout car vous ne pouvez de toute façon utiliser SFINAE que sur des modèles.

Pour moi, l'aspect lisibilité est le grand facteur de motivation dans ce choix.

std::enable_ifrepose sur le principe « L'échec de la sous-station n'est pas une erreur » (alias SFINAE) lors de la déduction des arguments de modèle . Il s'agit d'une fonctionnalité de langage très fragile et vous devez faire très attention pour bien faire les choses.

1. si votre condition à l'intérieur de enable_ifcontient un modèle imbriqué ou une définition de type (indice: recherchez des ::jetons), alors la résolution de ces tempatles ou types imbriqués est généralement un contexte non déduit . Tout échec de substitution sur un tel contexte non déduit est une erreur .
2. les diverses conditions dans de multiples enable_ifsurcharges ne peuvent pas avoir de chevauchement car la résolution de surcharge serait ambiguë. C'est quelque chose que vous devez vérifier vous-même en tant qu'auteur, même si vous obtenez de bons avertissements du compilateur.
3. enable_ifmanipule l'ensemble des fonctions viables pendant la résolution de surcharge qui peuvent avoir des interactions surprenantes en fonction de la présence d'autres fonctions qui sont importées d'autres portées (par exemple via ADL). Cela le rend peu robuste.

En bref, quand cela fonctionne, cela fonctionne, mais quand ce n'est pas le cas, cela peut être très difficile à déboguer. Une très bonne alternative est d'utiliser la distribution de balises , c'est-à-dire de déléguer à une fonction d'implémentation (généralement dans un detailespace de noms ou dans une classe d'assistance) qui reçoit un argument factice basé sur la même condition de compilation que vous utilisez dans le enable_if.

template<typename T>
T fun(T arg) 
{ 
    return detail::fun(arg, typename some_template_trait<T>::type() ); 
}

namespace detail {
    template<typename T>
    fun(T arg, std::false_type /* dummy */) { }

    template<typename T>
    fun(T arg, std::true_type /* dummy */) {}
}

La distribution de balises ne manipule pas l'ensemble de surcharge, mais vous aide à sélectionner exactement la fonction que vous voulez en fournissant les arguments appropriés via une expression à la compilation (par exemple dans un trait de type). D'après mon expérience, c'est beaucoup plus facile à déboguer et à faire correctement. Si vous êtes un rédacteur de bibliothèque en herbe de traits de type sophistiqués, vous en aurez peut-être besoin enable_if, mais pour la plupart des utilisations régulières des conditions de compilation, ce n'est pas recommandé.

Quelle solution privilégier et pourquoi éviter les autres?

• Le paramètre de modèle

  • Il est utilisable dans les constructeurs.
  • Il est utilisable dans l'opérateur de conversion défini par l'utilisateur.
  • Il nécessite C ++ 11 ou version ultérieure.
  • C'est l'OMI, le plus lisible.

  • Il peut facilement être mal utilisé et générer des erreurs avec des surcharges:

    template<typename T, typename = std::enable_if_t<std::is_same<T, int>::value>>
    void f() {/*...*/}
    
    template<typename T, typename = std::enable_if_t<std::is_same<T, float>::value>>
    void f() {/*...*/} // Redefinition: both are just template<typename, typename> f()

  Avis typename = std::enable_if_t<cond>au lieu de corrigerstd::enable_if_t<cond, int>::type = 0

• type de retour:

  • Il ne peut pas être utilisé dans le constructeur. (pas de type de retour)
  • Il ne peut pas être utilisé dans l'opérateur de conversion défini par l'utilisateur. (non déductible)
  • Il peut être utilisé avant C ++ 11.
  • Deuxième IMO plus lisible.

• Enfin, dans le paramètre de fonction:

  • Il peut être utilisé avant C ++ 11.
  • Il est utilisable dans les constructeurs.
  • Il ne peut pas être utilisé dans l'opérateur de conversion défini par l'utilisateur. (pas de paramètres)
  • Il ne peut pas être utilisée dans des procédés avec un nombre fixe d'arguments (opérateurs unaires / binaires +, -, *, ...)
  • Il peut être utilisé en toute sécurité en héritage (voir ci-dessous).
  • Changer la signature de la fonction (vous avez fondamentalement un supplément comme dernier argument void* = nullptr) (donc le pointeur de fonction serait différent, et ainsi de suite)

Existe-t-il des différences entre les modèles de fonctions membres et non membres?

Il existe des différences subtiles avec l'héritage et using:

Selon le using-declarator(c'est moi qui souligne):

namespace.udecl

L'ensemble des déclarations introduites par le déclarateur using est trouvé en effectuant une recherche de nom qualifié ([basic.lookup.qual], [class.member.lookup]) pour le nom dans le déclarateur using, en excluant les fonctions qui sont masquées comme décrit au dessous de.

...

Lorsqu'un déclarateur utilisant apporte des déclarations d'une classe de base dans une classe dérivée, les fonctions membres et les modèles de fonctions membres dans la classe dérivée remplacent et / ou masquent les fonctions membres et les modèles de fonctions membres avec le même nom, paramètre-type-list, cv- qualification, et ref-qualifier (le cas échéant) dans une classe de base (plutôt que conflictuelle). Ces déclarations masquées ou remplacées sont exclues de l'ensemble des déclarations introduites par le déclarateur using.

Ainsi, pour l'argument de modèle et le type de retour, les méthodes sont masquées est le scénario suivant:

struct Base
{
    template <std::size_t I, std::enable_if_t<I == 0>* = nullptr>
    void f() {}

    template <std::size_t I>
    std::enable_if_t<I == 0> g() {}
};

struct S : Base
{
    using Base::f; // Useless, f<0> is still hidden
    using Base::g; // Useless, g<0> is still hidden

    template <std::size_t I, std::enable_if_t<I == 1>* = nullptr>
    void f() {}

    template <std::size_t I>
    std::enable_if_t<I == 1> g() {}
};

Démo (gcc trouve mal la fonction de base).

Alors qu'avec un argument, un scénario similaire fonctionne:

struct Base
{
    template <std::size_t I>
    void h(std::enable_if_t<I == 0>* = nullptr) {}
};

struct S : Base
{
    using Base::h; // Base::h<0> is visible

    template <std::size_t I>
    void h(std::enable_if_t<I == 1>* = nullptr) {}
};

Démo