Warum sollte ich std :: enable_if in Funktionssignaturen vermeiden?

Scott Meyers veröffentlichte Inhalt und Status seines nächsten Buches EC ++ 11. Er schrieb, dass ein Punkt im Buch "Vermeiden Sie std::enable_ifin Funktionssignaturen" sein könnte .

std::enable_if kann als Funktionsargument, als Rückgabetyp oder als Klassenvorlage oder Funktionsvorlagenparameter verwendet werden, um Funktionen oder Klassen bedingt aus der Überlastungsauflösung zu entfernen.

In dieser Frage werden alle drei Lösungen gezeigt.

Als Funktionsparameter:

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; }   
};

Als Vorlagenparameter:

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; }   
};

Als Rückgabetyp:

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;
   }   
};

• Welche Lösung sollte bevorzugt werden und warum sollte ich andere vermeiden?
• In welchen Fällen betrifft " std::enable_ifIn Funktionssignaturen vermeiden " die Verwendung als Rückgabetyp (der nicht Teil der normalen Funktionssignatur, sondern der Vorlagenspezialisierungen ist)?
• Gibt es Unterschiede zwischen Funktionsvorlagen für Mitglieder und Nichtmitglieder?

Setzen Sie den Hack in die Vorlagenparameter .

Der enable_ifOn-Template-Parameter-Ansatz hat mindestens zwei Vorteile gegenüber den anderen:

• Lesbarkeit : Die Typen enable_if use und return / argument werden nicht zu einem unordentlichen Teil von Typnamen-Disambiguatoren und verschachtelten Typzugriffen zusammengeführt. Auch wenn die Unordnung des Disambiguators und des verschachtelten Typs mit Alias-Vorlagen verringert werden kann, würde dies dennoch zwei nicht miteinander verbundene Dinge zusammenführen. Die Verwendung von enable_if bezieht sich auf die Vorlagenparameter und nicht auf die Rückgabetypen. Wenn sie in den Vorlagenparametern enthalten sind, sind sie näher an dem, was wichtig ist.

• Universelle Anwendbarkeit : Konstruktoren haben keine Rückgabetypen, und einige Operatoren können keine zusätzlichen Argumente haben, sodass keine der beiden anderen Optionen überall angewendet werden kann. Das Einfügen von enable_if in einen Vorlagenparameter funktioniert überall, da Sie SFINAE ohnehin nur für Vorlagen verwenden können.

Für mich ist der Lesbarkeitsaspekt der große Motivationsfaktor bei dieser Wahl.

std::enable_ifstützt sich beim Abzug von Vorlagenargumenten auf das Prinzip " Substitionsfehler ist kein Fehler " (auch bekannt als SFINAE) . Dies ist eine sehr fragile Sprachfunktion, und Sie müssen sehr vorsichtig sein, um sie richtig zu machen.

1. Wenn Ihre Bedingung in der enable_ifeine verschachtelte Vorlage oder Typdefinition enthält (Hinweis: ::Suchen Sie nach Token), ist die Auflösung dieser verschachtelten Vorlagen oder Typen normalerweise ein nicht abgeleiteter Kontext . Jeder Substitutionsfehler in einem solchen nicht abgeleiteten Kontext ist ein Fehler .
2. Die verschiedenen Bedingungen bei mehreren enable_ifÜberladungen können keine Überlappung aufweisen, da die Überlastungsauflösung nicht eindeutig wäre. Dies ist etwas, das Sie als Autor selbst überprüfen müssen, obwohl Sie gute Compiler-Warnungen erhalten würden.
3. enable_ifmanipuliert den Satz funktionsfähiger Funktionen während der Überlastungsauflösung, die überraschende Wechselwirkungen haben können, abhängig vom Vorhandensein anderer Funktionen, die aus anderen Bereichen (z. B. über ADL) eingebracht werden. Dies macht es nicht sehr robust.

Kurz gesagt, wenn es funktioniert, funktioniert es, aber wenn es nicht funktioniert, kann es sehr schwer zu debuggen sein. Eine sehr gute Alternative ist die Verwendung des Tag-Dispatchings , dh das Delegieren an eine Implementierungsfunktion (normalerweise in einem detailNamespace oder in einer Hilfsklasse), die ein Dummy-Argument empfängt, das auf derselben Bedingung zur Kompilierungszeit basiert, die Sie in der verwenden 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 */) {}
}

Das Tag-Dispatching manipuliert den Überladungssatz nicht, hilft Ihnen jedoch bei der Auswahl genau der gewünschten Funktion, indem die richtigen Argumente über einen Ausdruck zur Kompilierungszeit (z. B. in einem Typmerkmal) bereitgestellt werden. Nach meiner Erfahrung ist dies viel einfacher zu debuggen und richtig zu machen. Wenn Sie ein aufstrebender Bibliotheksschreiber mit ausgefeilten Typmerkmalen sind, benötigen Sie möglicherweise etwas enable_if, aber für die meisten regelmäßigen Anwendungen zur Kompilierungszeit wird dies nicht empfohlen.

Welche Lösung sollte bevorzugt werden und warum sollte ich andere vermeiden?

• Der Vorlagenparameter

  • Es ist in Konstruktoren verwendbar.
  • Es kann in benutzerdefinierten Konvertierungsoperatoren verwendet werden.
  • Es erfordert C ++ 11 oder höher.
  • Es ist IMO, desto besser lesbar.

  • Es kann leicht falsch verwendet werden und führt zu Fehlern bei Überlastungen:

    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()

  Beachten Sie typename = std::enable_if_t<cond>statt richtigstd::enable_if_t<cond, int>::type = 0

• Rückgabetyp:

  • Es kann nicht im Konstruktor verwendet werden. (kein Rückgabetyp)
  • Es kann nicht in benutzerdefinierten Konvertierungsoperatoren verwendet werden. (nicht ableitbar)
  • Es kann Pre-C ++ 11 verwendet werden.
  • Zweitens besser lesbare IMO.

• Zuletzt im Funktionsparameter:

  • Es kann Pre-C ++ 11 verwendet werden.
  • Es ist in Konstruktoren verwendbar.
  • Es kann nicht in benutzerdefinierten Konvertierungsoperatoren verwendet werden. (keine Parameter)
  • Es kann nicht mit fester Anzahl von Argumenten (einstellige / binäre Operatoren in Verfahren verwendet werden +, -, *, ...)
  • Es kann sicher bei der Vererbung verwendet werden (siehe unten).
  • Ändern Sie die Funktionssignatur (Sie haben im Grunde ein Extra als letztes Argument void* = nullptr) (der Funktionszeiger würde sich also unterscheiden und so weiter).

Gibt es Unterschiede zwischen Funktionsvorlagen für Mitglieder und Nichtmitglieder?

Es gibt subtile Unterschiede bei der Vererbung und using:

Nach dem using-declarator(Schwerpunkt Mine):

namespace.udecl

Der vom using-Deklarator eingeführte Satz von Deklarationen wird gefunden, indem eine qualifizierte Namenssuche ([basic.lookup.qual], [class.member.lookup]) für den Namen im using-Deklarator durchgeführt wird, mit Ausnahme von Funktionen, die wie beschrieben ausgeblendet sind unten.

...

Wenn ein using-Deklarator Deklarationen von einer Basisklasse in eine abgeleitete Klasse bringt, überschreiben und / oder verbergen Elementfunktionen und Elementfunktionsvorlagen in der abgeleiteten Klasse Elementfunktionen und Elementfunktionsvorlagen mit demselben Namen, Parametertypliste, cv- Qualifikation und Ref-Qualifikation (falls vorhanden) in einer Basisklasse (anstatt widersprüchlich). Solche versteckten oder überschriebenen Deklarationen sind von den vom using-Deklarator eingeführten Deklarationen ausgeschlossen.

Sowohl für das Vorlagenargument als auch für den Rückgabetyp sind die folgenden Methoden ausgeblendet:

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() {}
};

Demo (gcc findet fälschlicherweise die Basisfunktion).

Während mit Argument ein ähnliches Szenario funktioniert:

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) {}
};

Demo