std enable if to conditionally compile a member function

Question

I am trying to get a simple example to work to understand how to use std  enable if  After I read this answer  I thought it shouldn t be too hard to come up with a simple example  I want to use std  enable if to choose between two member-functions and allow only one of them to be used   Unfortunately  the following doesn t compile with gcc 4 7 and after hours and hours of trying I am asking you guys what my mistake is    include  lt utility gt   include  lt iostream gt   template lt  class T  gt  class Y        public          template  lt  typename   typename std  enable if lt  true  gt   type  gt          T foo                 return 10                    template  lt  typename   typename std  enable if lt  false  gt   type  gt          T foo                 return 10                  int main         Y lt  double  gt  y       std  cout  lt  lt  y foo    lt  lt  std  endl      gcc reports the following problems     LANG C make CXXFLAGS  -std c  0x  enable if g   -std c  0x    enable if cpp   -o enable if enable if cpp 12 65  error   type  in  struct std  enable if lt false gt   does not name a type enable if cpp 13 15  error   template lt class T gt  template lt class gt  T Y  foo    cannot be overloaded enable if cpp 9 15  error  with  template lt class T gt  template lt class gt  T Y  foo      Why doesn t g   delete the wrong instantiation for the second member function  According to the standard  std  enable if lt  bool  T   void  gt   type only exists when the boolean template parameter is true  But why doesn t g   consider this as SFINAE  I think that the overloading error message comes from the problem that g   doesn t delete the second member function and believes that this should be an overload

User · Answer

The boolean needs to depend on the template parameter being deduced. So an easy way to fix is to use a default boolean parameter:

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

};

However, this won't work if you want to overload the member function. Instead, its best to use TICK_MEMBER_REQUIRES from the Tick library:

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

};

You can also implement your own member requires macro like this(just in case you don't want to use another library):

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

User · Answer

For those late-comers that are looking for a solution that  just works     include  lt utility gt   include  lt iostream gt   template lt  typename T  gt  class Y        template lt  bool cond  typename U  gt      using resolvedType    typename std  enable if lt  cond  U  gt   type        public          template lt  typename U   T  gt           resolvedType lt  true  U  gt  foo                 return 11                    template lt  typename U   T  gt          resolvedType lt  false  U  gt  foo                 return 12                  int main         Y lt  double  gt  y       std  cout  lt  lt  y foo    lt  lt  std  endl      Compile with   g   -std gnu  14 test cpp    Running gives     a out  11

User · Answer

Here is my minimalist example  using a macro  Use double brackets enable if        when using more complex expressions  template lt bool b  std  enable if t lt b  int gt    0 gt  using helper enable if   int    define enable if value  typename   helper enable if lt value gt   struct Test        template lt enable if false  gt       void run

User · Answer

SFINAE only works if substitution in argument deduction of a template argument makes the construct ill-formed  There is no such substitution       I thought of that too and tried to use std  is same lt  T  int  gt   value and   std  is same lt  T  int  gt   value which gives the same result    That s because when the class template is instantiated  which happens when you create an object of type Y lt int gt  among other cases   it instantiates all its member declarations  not necessarily their definitions bodies    Among them are also its member templates  Note that T is known then  and  std  is same lt  T  int  gt   value yields false  So it will create a class Y lt int gt  which contains  class Y lt int gt        public             instantiated from         template  lt  typename   typename std  enable if lt             std  is same lt  T  int  gt   value  gt   type  gt          T foo                 return 10                                template  lt  typename   typename std  enable if lt  true  gt   type  gt          int foo                instantiated from          template  lt  typename   typename std  enable if lt               std  is same lt  T  int  gt   value  gt   type  gt          T foo                 return 10                                template  lt  typename   typename std  enable if lt  false  gt   type  gt          int foo         The std  enable if lt false gt   type accesses a non-existing type  so that declaration is ill-formed  And thus your program is invalid    You need to make the member templates  enable if depend on a parameter of the member template itself  Then the declarations are valid  because the whole type is still dependent  When you try to call one of them  argument deduction for their template arguments happen and SFINAE happens as expected  See this question and the corresponding answer on how to do that

User · Answer

From this post      Default template arguments are not part of the signature of a template   But one can do something like this    include  lt iostream gt   struct Foo       template  lt  class T                 class std  enable if  lt   std  is integral lt T gt   value  int  gt   type   0  gt      void f const T amp  value                std  cout  lt  lt   Not int   lt  lt  std  endl             template lt class T               class std  enable if lt std  is integral lt T gt   value  int gt   type   0 gt      void f const T amp  value                std  cout  lt  lt   Int   lt  lt  std  endl            int main         Foo foo      foo f 1       foo f 1 1           Output         Int        Not int

User · Answer

I made this short example which also works    include  lt iostream gt   include  lt type traits gt   class foo  class bar   template lt class T gt  struct is bar       template lt class Q   T gt      typename std  enable if lt std  is same lt Q  bar gt   value  bool gt   type check                 return true             template lt class Q   T gt      typename std  enable if lt  std  is same lt Q  bar gt   value  bool gt   type check                 return false            int main         is bar lt foo gt  foo is bar      is bar lt bar gt  bar is bar      if   foo is bar check    amp  amp  bar is bar check            std  cout  lt  lt   It works    lt  lt  std  endl       return 0      Comment if you want me to elaborate  I think the code is more or less self-explanatory  but then again I made it so I might be wrong     You can see it in action here

User · Answer

One way to solve this problem  specialization of member functions is to put the specialization into another class  then inherit from that class  You may have to change the order of inheritence to get access to all of the other underlying data but this technique does work   template lt  class T  bool condition gt  struct FooImpl  template lt class T gt  struct FooImpl lt T  true gt    T foo     return 10        template lt class T gt  struct FoolImpl lt T false gt    T foo     return 5        template lt  class T  gt  class Y   public FooImpl lt T  boost  is integer lt T gt   gt     whatever your test is goes here    public      typedef FooImpl lt T  boost  is integer lt T gt   gt  inherited          you will need to use  inherited    if you want to name any of the         members of those inherited classes       The disadvantage of this technique is that if you need to test a lot of different things for different member functions you ll have to make a class for each one  and chain it in the inheritence tree  This is true for accessing common data members   Ex   template lt class T  bool condition gt  class Goo     repeat pattern above   template lt class T  bool condition gt  class Foo lt T  true gt    public Goo lt T  boost  test lt T gt   gt    public      typedef Goo lt T  boost  test lt T gt   gt  inherited         etc  etc

[c++] std::enable_if to conditionally compile a member function

Examples related to c++

Examples related to templates

Examples related to g++

Examples related to c++11