Question

I was wondering if it was possible to create a class that would serve as a combination between std::enable_if and a SFINAE member detector.

class foo
{
public:
    int bar;
};

template <class T>
typename enable_if_has_bar<T>::type ReturnBar (const T& value)
{
    return value.bar;
}

So I attempted to do this.

class foo
{
public:
    int bar;
};

template <class C, C>
class Check;

template <class T, class Enable = void>
class enable_if_has_bar
{};

template <class T>
class enable_if_has_bar<T, Check <decltype(&T::bar),&T::bar>>
{
public:
    typedef decltype(static_cast<T*>(0)->*static_cast<decltype(&T::bar)>(0)) type;
};

template <class T>
typename enable_if_has_bar<T>::type ReturnBar (const T& value)
{
    return value.bar;
}

int main ()
{
    foo foobar;
    foobar.bar = 42;

    cout << ReturnBar(foobar) << endl;
}

( http://ideone.com/WKTfmQ )

It doesn’t seem to work, and I’m not quite as versed in the fine art of SFINAE as I could be. Perhaps someone could improve/fix it? Because I’m at a loss.

Answer 1

I generally prefer to create custom enable_if-style types as you’ve attempted, because I find the code clearer to read with a single trait type, rather than a combination of enable_if<some_trait<T>, another_trait<T>>. But in this case there are a few problems in your code stopping it working.

Your enable_if_has_bar specialization will never be selected, the return type of ReturnBar just instantiates the primary template, enable_if_has_bar<foo, void>, and that never defines the nested type. Nothing causes the specialization to be instantiated so there is nothing that checks whether T::bar is a valid expression.

Your decltype(static_cast<T*>(0)->*static_cast<decltype(&T::bar)>(0)) expression will result in int& not int as you probably want. This is because decltype(foobar.*(&foo::bar)) is equivalent to decltype(foobar.bar) and foobar.bar is an lvalue, so the decltype is int&. The function ReturnBar would fail to compile if it returns int& because the parameter value is const, so you can’t bind value.bar to a non-const int&.

Here’s a working version:

template <class T>
  class has_bar
  {
    template<typename U, typename = decltype(&U::bar)>
      static std::true_type
      test(U*);

    static std::false_type
    test(...);

  public:
    static const int value = decltype(test((T*)nullptr))::value;
  };

template<typename T, bool = has_bar<T>::value>
  struct enable_if_has_bar
  { };

template<typename T>
  struct enable_if_has_bar<T, true>
  : std::decay<decltype(std::declval<T&>().*(&T::bar))>
  { };

This first declares the helper has_bar to answer the question of whether the type has the nested member. That helper uses SFINAE to get a true or false value. If &T::bar is a valid expression then the first overload of test will be used, which returns true_type and so value will be set to true_type::value i.e. true. Otherwise the fallback overload will be selected and value set to false.

Then the enable_if_has_bar template uses a default template parameter which is deduced as the value of has_bar<T>::value. The primary template is used when has_bar<T>::value is false. The specialization is used when has_bar<T>::value is true, in which case we know the expression &T::bar is valid and can use it in a decltype expression to get the type.

std::decay is used to turn the int& result of the decltype expression to just int. Inheriting from decay is a bit shorter than using it to define the member, which would be:

typedef typename std::decay<decltype(std::declval<T&>().*(&T::bar))>::type type;

I used the standard utility declval<T>() in the unevaluated expressions, which is a bit shorter to type and a bit more idiomatic and expressive than static_cast<T*>(0).

An alternative to using decay would be another helper type to get the type int from the type int T::* e.g.

template<typename T>
  struct remove_class;
  { };

template<typename Member, typename Class>
  struct remove_class<Member Class::*>
  {
    typedef Member type;
  };

template<typename T>
  struct enable_if_has_bar<T, true>
  : remove_class<decltype(&T::bar)>
  { };

(The name remove_class isn’t very good, but basically it takes a pointer-to-data-member type and gives the type of the member.)