std::activer si conditionnelle, de compiler une fonction membre

j'ai fait ce petit exemple qui fonctionne aussi.

#include <iostream>
#include <type_traits>

class foo;
class bar;

template<class T>
struct check
{
    template<class Q = T>
    typename std::enable_if<std::is_same<Q, bar>::value, bool>::type test()
    {
        return true;
    }

    template<class Q = T>
    typename std::enable_if<!std::is_same<Q, bar>::value, bool>::type test()
    {
        return false;
    }
};

int main()
{
    check<foo> check_foo;
    check<bar> check_bar;
    if (!check_foo.test() && check_bar.test())
        std::cout << "It works!" << std::endl;

    return 0;
}

commentaire si vous voulez que je développe. Je pense que le code est plus ou moins explicite, mais là encore je l'ai fait pour que je puisse me tromper:)

vous pouvez le voir en action ici .

pour les retardataires qui cherchent une solution qui "fonctionne":

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

compiler avec:

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

en cours d'Exécution donne:

./a.out 
11

à Partir de ce post":

les arguments de modèle par défaut ne font pas partie de la signature d'un modèle

mais on peut faire quelque chose comme ça:

#include <iostream>

struct Foo {
    template < class T,
               class std::enable_if < !std::is_integral<T>::value, int >::type = 0 >
    void f(const T& value)
    {
        std::cout << "Not int" << std::endl;
    }

    template<class T,
             class std::enable_if<std::is_integral<T>::value, int>::type = 0>
    void f(const T& value)
    {
        std::cout << "Int" << std::endl;
    }
};

int main()
{
    Foo foo;
    foo.f(1);
    foo.f(1.1);

    // Output:
    // Int
    // Not int
}

une façon de résoudre ce problème, la spécialisation des fonctions des membres est de mettre la spécialisation dans une autre classe, puis hériter de cette classe. Vous devrez peut-être changer l'ordre de succession pour avoir accès à toutes les autres données sous-jacentes, mais cette technique fonctionne.

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

L'inconvénient de cette technique est que si vous avez besoin de tester un grand nombre de différentes choses pour différentes fonctions de membre vous aurez à faire une classe pour chacun d'eux, et de la chaîne dans l'héritage de l'arbre. Cela est vrai pour l'accès aux membres de données communes.

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

le booléen doit dépendre du paramètre template déduit. Donc une façon facile de corriger est d'utiliser un paramètre booléen par défaut:

template< class T >
class Y {

    public:
        template < bool EnableBool = true, typename = typename std::enable_if<( std::is_same<T, double>::value && EnableBool )>::type >
        T foo() {
            return 10;
        }

};

Toutefois, cela ne fonctionnera pas si vous voulez surcharger la fonction de membre. Au lieu de cela, son meilleur pour utiliser TICK_MEMBER_REQUIRES de la Tic bibliothèque:

template< class T >
class Y {

    public:
        TICK_MEMBER_REQUIRES(std::is_same<T, double>::value)
        T foo() {
            return 10;
        }

        TICK_MEMBER_REQUIRES(!std::is_same<T, double>::value)
        T foo() {
            return 10;
        }

};

vous pouvez également mettre en œuvre votre propre membre nécessite macro comme ceci(juste au cas où vous ne vous voulez utiliser une autre bibliothèque):

template<long N>
struct requires_enum
{
    enum class type
    {
        none,
        all       
    };
};


#define MEMBER_REQUIRES(...) \
typename requires_enum<__LINE__>::type PrivateRequiresEnum ## __LINE__ = requires_enum<__LINE__>::type::none, \
class=typename std::enable_if<((PrivateRequiresEnum ## __LINE__ == requires_enum<__LINE__>::type::none) && (__VA_ARGS__))>::type