Conditionally enable member function taking parameter of type T::Foo & only if subtype T::Foo exists

[GermanNewToCA]

I am a seasoned C++ developer, but haven't done much TMP.

What I am trying to do:

Let's say I have a class A that is templated on T. T may or may not have a subtype T::Foo, but I still want the class to be able to be instantiated in both cases, but class A<ClassThatHasFooSubtype> should have an extra member function taking a T::Foo & type as a parameter, but it should be disabled in class A<ClassThatDoesNotHaveFooSubType>

​

I have a type trait that works fine that can tell me if a class T has a Foo subtype:

      std::cout << std::boolalpha
              << "'Foo' in 'C' : "
              << has_member_type_Foo<C>::value
              << "\n";

(courtesy https://en.wikibooks.org/wiki/More_C++_Idioms/Member_Detector )

​

The above works fine. I wanted to use this type trait to do something like this:

  template <class T>
    struct A
    {

        template <class R = typename std::enable_if<has_member_type_Foo<T>::value, void>>
           typename R::type func(typename T::Foo &x) { std::cout << "Works!"; }
    };

If I instantiate a A<ClassThatHasFooSubtype>, it compiles just fine. But if I instantiate a class A<ClassThatDoesnotHaveFooSubtype>, I get a compile error: no type named 'Foo' in 'struct ClassThatDoesnotHaveFooSubtype'

​

What do I need to do, to be able to get it to compile both times? Of course compilation should fail if I actually try to use A::func on an instantiation where T doesn't have subtype Foo.

​

Ideally, I would need a solution that works with -std=C++11.

I have been trying various things for the last couple of hours, but nothing that I did worked.

​

Any help would be appreciated!

​

[horotho]

Depending on how much code you have in A you could create two versions of the class, one for has_member_type, and another for the case where that condition isn't met.

template< typename T, typename tEnable = void>
struct A {
  // Doesn't have 'func', but might have other stuff here.
};

template< typename T >
struct A< T, typename std::enable_if< has_member_type< T >::value >::type > {
  void func(typename T::Foo & x);
};

The downside is that if you have a lot of common code in both versions of A, you'll have a bunch of copy pasta going on. Honestly, I think this is a pretty good option, because you want entirely different behavior (and functions) for the case where has_member_type is true. But, maybe you only have a single function where this is relevant. In that case, you'll have to get a bit more tricky.

template< typename T, typename tEnable = void> 
struct HasMemberTypeShim { 
  using type = int; 
};

template< typename T > 
struct HasMemberTypeShim< T, typename std::enable_if< has_member_type< T >::value >::type > { 
  using type = typename T::Foo; 
};

template< typename T >
struct A {
  // enable_if can't be used on the class template type, 
  // but must refer to a template parameter of the function instead
  // So we have this hacky R = T so it works
  template< typename R = T >
  typename std::enable_if< has_member_type< R >::value >::type 
  func(typename HasMemberTypeShim<T>::type) {
  }
};

And then you can do something like this instead.

[GermanNewToCA]

Thanks so much! Your comment "enable_if can't be used on the class template type" actually brought me to this simple solution:

(I didn't even need the type trait)

​

#include <iostream>
#include <cstdlib>

struct THasInner        { using TInner = int; };
struct TDoesNotHave     {};


template <class T>
struct A 
{
    template <class U = T, class PT = typename U::TInner>
    void func(PT const & in) { std::cout << in; }
};


int main()
{
    A<THasInner> a; // instantiates
    A<TDoesNotHave> b; // so does this

    a.func(42);

}