Using SFINAE with member function templates

Yes, you can use SFINAE with member function templates. SFINAE is a powerful metaprogramming technique that allows you to write template code that can be selectively enabled or disabled based on the template arguments.

Here's a simple example of how you might use SFINAE with a member function template:

1#include <iostream>
2#include <type_traits>
3
4class MyClass {
5 public:
6  template <typename T, std::enable_if_t<
7    std::is_integral_v<T>, bool> = true>
8  void func(T x) {
9    std::cout << "func for integral types: "
10      << x << std::endl;
11  }
12
13  template <typename T, std::enable_if_t<
14    std::is_floating_point_v<T>, bool> = true>
15  void func(T x) {
16    std::cout << "func for floating-point "
17      "types: " << x << std::endl;
18  }
19};
20
21int main() {
22  MyClass obj;
23  // calls func for integral types
24  obj.func(42);    
25
26  // calls func for floating-point types
27  obj.func(3.14);
28}

1func for integral types: 42
2func for floating-point types: 3.14

In this code, MyClass has two member function templates named func. Both take a single parameter x of type T. However, they also have a second, unnamed template parameter.

This second parameter uses std::enable_if and type traits to conditionally enable or disable each function. The first func is only enabled if T is an integral type, while the second func is only enabled if T is a floating-point type.

When we call obj.func(42), the compiler tries to instantiate both templates. The first one succeeds because int is an integral type, but the second one fails because int is not a floating-point type. However, because of SFINAE, this failure is not an error. The compiler simply discards the second template and uses the first one.

Similarly, when we call obj.func(3.14), the first template fails (because double is not an integral type), but the second one succeeds.

SFINAE allows you to write templates that adapt to the capabilities of their template arguments. This can be used for things like conditionally providing different implementations based on the presence of certain member functions or operators in the template arguments.

However, SFINAE can also make your code more complex and harder to read, so it should be used judiciously. Modern C++ also provides other mechanisms for conditional templates, like if constexpr and concepts, which can often be simpler and clearer than SFINAE.