“What happened to my SFINAE” redux: conditional template class members?

by

Firstly, C++11 did not carry forward boost’s disable_if. So if you’re going to transition boost code, you’ll need to use enable_if with a negated condition (or redefine your own disable_if construct).

Secondly, for SFINAE to reach in and apply to the method level, those methods must be templates themselves. Yet your tests have to be done against those templates’ parameters…so code like enable_if<is_pointer<T> will not work. You can finesse this by making some template argument (let’s say X) default to be equal to T, and then throw in a static assertion that the caller has not explicitly specialized it to something else.

This means that instead of writing:

template <typename T>
struct Foo {
    typename enable_if<is_pointer<T>::value, void>::type
    valid_if_pointer(T) const { /* ... */ }

    typename disable_if<is_pointer<T>::value, void>::type
    valid_if_not_pointer(T) const { /* ... */ }
};

…you would write:

template <typename T>
struct Foo {
    template <typename X=T>
    typename enable_if<is_pointer<X>::value, void>::type
    valid_if_pointer(T) const {
        static_assert(is_same<X,T>::value, "can't explicitly specialize");
        /* ... */
    }

    template <typename X=T>    
    typename enable_if<not is_pointer<X>::value, void>::type
    valid_if_not_pointer(T) const {
        static_assert(is_same<X,T>::value, "can't explicitly specialize");
        /* ... */
    }
};

Both are now templates and the enable_if uses the template parameter X, rather than T which is for the whole class. It’s specifically about the substitution that happens whilst creating the candidate set for overload resolution–in your initial version there’s no template substitution happening during the overload resolution.

Note that the static assert is there to preserve the intent of the original problem, and prevent someone being able to compile things like:

Foo<int>().valid_if_pointer<int*>(someInt);

More Related Contents:

  1. Checking a member exists, possibly in a base class, C++11 version
  2. What is decltype with two arguments?
  3. How can you iterate over the elements of an std::tuple?
  4. Check if a class has a member function of a given signature
  5. Why do constant expressions have an exclusion for undefined behavior?
  6. What is “Expression SFINAE”?
  7. Metaprograming: Failure of Function Definition Defines a Separate Function
  8. Creating an array initializer from a tuple or variadic template parameters
  9. Selecting a member function using different enable_if conditions
  10. Why is there not an std::is_struct type trait?
  11. Why should I avoid std::enable_if in function signatures
  12. check variadic templates parameters for uniqueness
  13. How to make generic computations over heterogeneous argument packs of a variadic template function?
  14. Is it possible to determine if a type is a scoped enumeration type?
  15. SFINAE works differently in cases of type and non-type template parameters
  16. void_t “can implement concepts”?
  17. How to use sfinae for selecting constructors?
  18. Disambiguate overloaded member function pointer being passed as template parameter
  19. Which cannot be implemented without compiler hooks?
  20. C++11 “overloaded lambda” with variadic template and variable capture
  21. TMP: how to generalize a Cartesian Product of Vectors?
  22. False positive with is_copy_constructible on vector
  23. C++11 is_same type trait for templates
  24. using SFINAE for template class specialisation
  25. Generating one class member per variadic template argument
  26. Assert that code does NOT compile
  27. Detect operator support with decltype/SFINAE
  28. Is substitution performed on a variadic parameter pack type if the pack is empty?
  29. Concatenate compile-time strings in a template at compile time?
  30. should std::common_type use std::decay?

Leave a Comment