std::enable_if zum bedingten kompilieren einer member-Funktion

SFINAE funktioniert nur, wenn die substitution im argument der Abzug von template-argument macht das Konstrukt schlecht ausgebildet. Es gibt keine solche substitution.

Ich dachte das auch und habe std::is_same< T, int >::value und ! std::is_same< T, int >::value gibt das gleiche Ergebnis.

Das ist, weil, wenn der Vorlage-Klasse instanziiert wird (was passiert, wenn Sie erstellen ein Objekt vom Typ Y<int> zu anderen Fällen), instanziiert es alle seine member-Deklarationen (nicht unbedingt zu Ihren Definitionen und/oder Einrichtungen!). Unter Ihnen sind auch seine Mitglied-Vorlagen. Beachten Sie, dass T bekannt ist, und dann !std::is_same< T, int >::value ergibt false. Also wird es eine Klasse Y<int> enthält

class Y<int> {
    public:
        /* instantiated from
        template < typename = typename std::enable_if< 
          std::is_same< T, int >::value >::type >
        T foo() {
            return 10;
        }
        */

        template < typename = typename std::enable_if< true >::type >
        int foo();

        /* instantiated from

        template < typename = typename std::enable_if< 
          ! std::is_same< T, int >::value >::type >
        T foo() {
            return 10;
        }
        */

        template < typename = typename std::enable_if< false >::type >
        int foo();
};

Den std::enable_if<false>::type Zugriff auf einen nicht vorhandenen Typ, also, die Erklärung ist schlecht ausgebildet. Und damit Ihr Programm ist ungültig.

Müssen Sie dem betreffenden Vorlagen' enable_if hängt von einem parameter des betreffenden Vorlage selbst. Dann gelten die Erklärungen, weil der ganze Typ ist immer noch abhängig. Wenn Sie versuchen, rufen Sie einen von Ihnen, argument-Abzug Ihrer Vorlage Argumenten geschehen, und SFINAE passiert, wie erwartet. Sehen diese Frage und die entsprechende Antwort, wie das zu tun.

InformationsquelleAutor Johannes Schaub - litb

Für diejenigen, die spät-Ankömmlinge, die auf der Suche nach einer Lösung, die "einfach funktioniert":

#include <utility>
#include <iostream>

template< typename T >
class Y {

    template< bool cond, typename U >
    using resolvedType  = typename std::enable_if< cond, U >::type; 

    public:
        template< typename U = T > 
        resolvedType< true, U > foo() {
            return 11;
        }
        template< typename U = T >
        resolvedType< false, U > foo() {
            return 12;
        }

};


int main() {
    Y< double > y;

    std::cout << y.foo() << std::endl;
}

Kompilieren mit:

g++ -std=gnu++14 test.cpp 

Laufen gibt:

./a.out 
11

InformationsquelleAutor user1284631

Einen Weg, um dieses problem zu lösen, Spezialisierung von member-Funktionen ist die Spezialisierung in eine andere Klasse, dann Erben von dieser Klasse. Sie müssen möglicherweise ändern Sie die Reihenfolge der inheritence, erhalten Sie Zugriff auf alle anderen zugrunde liegenden Daten aber diese Technik funktioniert.

template< class T, bool condition> struct FooImpl;
template<class T> struct FooImpl<T, true> {
T foo() { return 10; }
};

template<class T> struct FoolImpl<T,false> {
T foo() { return 5; }
};

template< class T >
class Y : public FooImpl<T, boost::is_integer<T> > //whatever your test is goes here.
{
public:
    typedef FooImpl<T, boost::is_integer<T> > inherited;

    //you will need to use "inherited::" if you want to name any of the 
    //members of those inherited classes.
};

Der Nachteil dieser Technik ist, dass, wenn Sie brauchen, um zu testen, eine Menge verschiedener Dinge für verschiedene member-Funktionen haben Sie, um eine Klasse für jeden, und die Kette die es in der inheritence tree. Dies gilt für den Zugriff auf gemeinsame Daten Mitglieder.

Ex:

template<class T, bool condition> class Goo;
//repeat pattern above.

template<class T, bool condition>
class Foo<T, true> : public Goo<T, boost::test<T> > {
public:
    typedef Goo<T, boost::test<T> > inherited:
    //etc. etc.
};

InformationsquelleAutor Gary Powell