How Does std::enable_if work?

by

As is mentioned in comment by 40two, understanding of Substitution Failure Is Not An Error is a prerequisite for understanding std::enable_if.

std::enable_if is a specialized template defined as:

template<bool Cond, class T = void> struct enable_if {};
template<class T> struct enable_if<true, T> { typedef T type; };

The key here is in the fact that typedef T type is only defined when bool Cond is true.

Now armed with that understanding of std::enable_if it’s clear that void foo(const T &bar) { isInt(bar); } is defined by:

template<typename T>
typename std::enable_if<std::numeric_limits<T>::is_integer, void>::type foo(const T &bar) { isInt(bar); }

As mentioned in firda’s answer, the = 0 is a defaulting of the second template parameter. The reason for the defaulting in template<typename T, typename std::enable_if<std::is_integral<T>::value, int>::type = 0> is so that both options can be called with foo< int >( 1 );. If the std::enable_if template parameter was not defaulted, calling foo would require two template parameters, not just the int.

General note, this answer is made clearer by explicitly typing out typename std::enable_if<std::numeric_limits<T>::is_integer, void>::type but void is the default second parameter to std::enable_if, and if you have c++14 enable_if_t is a defined type and should be used. So the return type should condense to: std::enable_if_t<std::numeric_limits<T>::is_integer>

A special note for users of visual-studio prior to visual-studio-2013: Default template parameters aren’t supported, so you’ll only be able to use the enable_if on the function return: std::numeric_limits as a Condition

More Related Contents:

  1. Why should I avoid std::enable_if in function signatures
  2. Template specialization and enable_if problems [duplicate]
  3. Default template argument when using std::enable_if as templ. param.: why OK with two template functions that differ only in the enable_if parameter?
  4. using extern template (C++11)
  5. SFINAE working in return type but not as template parameter
  6. What exactly is the “immediate context” mentioned in the C++11 Standard for which SFINAE applies?
  7. Specifying one type for all arguments passed to variadic function or variadic template function w/out using array, vector, structs, etc?
  8. Why doesn’t SFINAE (enable_if) work for member functions of a class template?
  9. How to write a type trait `is_container` or `is_vector`?
  10. Detecting constexpr with SFINAE
  11. Alias template specialisation
  12. Matching alias template as template argument
  13. What do compilers do with compile-time branching?
  14. Is it possible to “store” a template parameter pack without expanding it?
  15. How do compilers treat variable length arrays
  16. C++11: Compile Time Calculation of Array
  17. How to reverse the order of arguments of a variadic template function?
  18. Doing a static_assert that a template type is another template
  19. Populate An Array Using Constexpr at Compile-time
  20. Forwarding all constructors in C++0x
  21. Lambda expressions as class template parameters
  22. Is there a compiler bug exposed by my implementation of an is_complete type trait?
  23. Using export keyword with templates
  24. How to make a variadic is_same?
  25. Returning a void?
  26. std::remove_const with const references
  27. Passing a lambda into a function template
  28. How to typedef a template class? [duplicate]
  29. Partial specialization of function templates
  30. Dynamic dispatching of template functions?

Leave a Comment