SFINAE works differently in cases of type and non-type template parameters

by

SFINAE is about substitution. So let us substitute!

template<
  typename T, 
  std::enable_if_t<std::is_same<T, int>::value, T>* = nullptr>
void Add(T) {}

template<
  typename T, 
  std::enable_if_t<!std::is_same<T, int>::value, T>* = nullptr>
void Add(T) {}

Becomes:

template<
  class T=int, 
  int* = nullptr>
void Add(int) {}

template<
  class T=int, 
  Substitution failure* = nullptr>
void Add(int) {

template<
  class T=double, 
  Substitution failure* = nullptr>
void Add(double) {}

template<
  class T=double
  double* = nullptr>
void Add(double) {}

Remove failures we get:

template<
  class T=int, 
  int* = nullptr>
void Add(int) {}
template<
  class T=double
  double* = nullptr>
void Add(double) {}

Now remove template parameter values:

template<
  class T, 
  int*>
void Add(T) {}
template<
  class T
  double*>
void Add(T) {}

These are different templates.

Now the one that messes up:

template<
  typename T, 
  typename = typename std::enable_if<std::is_same<T, int>::value, T>::type>
void Add(T) {}

template<
  typename T, 
  typename = typename std::enable_if<!std::is_same<T, int>::value, T>::type>
void Add(T) {}

Becomes:

template<
  typename T=int, 
  typename =int>
void Add(int) {}

template<
  typename int, 
  typename = Substitution failure >
void Add(int) {}

template<
  typename T=double, 
  typename = Substitution failure >
void Add(double) {}

template<
  typename T=double, 
  typename = double>
void Add(double) {}

Remove failures:

template<
  typename T=int, 
  typename =int>
void Add(int) {}
template<
  typename T=double, 
  typename = double>
void Add(double) {}

And now template parameter values:

template<
  typename T, 
  typename>
void Add(T) {}
template<
  typename T, 
  typename>
void Add(T) {}

These are the same template signature. And that is not allowed, error generated.

Why is there such a rule? Beyond the scope of this answer. I’m simply demonstrating how the two cases are different, and asserting that the standard treats them differently.

When you use a non-type template parameter like the above, you change the template signature not just the template parameter values. When you use a type template parameter like the above, you only change the template parameter values.

More Related Contents:

  1. Check if a class has a member function of a given signature
  2. SFINAE working in return type but not as template parameter
  3. What exactly is the “immediate context” mentioned in the C++11 Standard for which SFINAE applies?
  4. What is “Expression SFINAE”?
  5. Selecting a member function using different enable_if conditions
  6. Why should I avoid std::enable_if in function signatures
  7. Detecting constexpr with SFINAE
  8. Template specialization and enable_if problems [duplicate]
  9. using SFINAE for template class specialisation
  10. Why does overload of template and non-template function with the “same signature” call the non-template function?
  11. Optimization code for a debug function (c++11 with templates) [closed]
  12. C++11 does not deduce type when std::function or lambda functions are involved
  13. How to detect whether there is a specific member variable in class?
  14. Why do constant expressions have an exclusion for undefined behavior?
  15. SFINAE to check for inherited member functions
  16. When to use std::forward to forward arguments?
  17. What’s a use case for overloading member functions on reference qualifiers?
  18. How to detect existence of a class using SFINAE?
  19. check if member exists using enable_if
  20. What does this variadic template code do?
  21. C++ template functions overload resolution
  22. Expansion with variadic templates [duplicate]
  23. C++ overloaded function as template argument
  24. Variadic function template with pack expansion not in last parameter
  25. 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?
  26. C++11 is_same type trait for templates
  27. Why the initializer of std::function has to be CopyConstructible?
  28. Interfacing C++11 array with Cython
  29. How to typedef a template class? [duplicate]
  30. How to test whether class B is derived from template family of classes

Leave a Comment