Applying SFINAE to Variadic Templates

Yes, SFINAE can be applied to variadic templates. This is often used to check properties of the types in a parameter pack.

Here's an example that implements a are_all_same function that checks if all types in a variadic template are the same:

1#include <iostream>
2#include <type_traits>
3
4template <typename T, typename... Rest>
5constexpr bool are_all_same() {
6  return (std::is_same_v<T, Rest> && ...);
7}
8
9template <typename... Ts, std::enable_if_t<
10  are_all_same<Ts...>(), int> = 0>
11void foo(Ts...) {
12  std::cout << "All types are the same\n";
13}
14
15template <typename... Ts, std::enable_if_t<
16  !are_all_same<Ts...>(), int> = 0>
17void foo(Ts...) {
18  std::cout << "Types are not all the same\n";
19}
20
21int main() {
22  foo(1, 2, 3);     // Uses second template
23  foo(1, 2, 3.14);  // Uses second template
24  foo(1, 1, 1);     // Uses first template
25}

1All types are the same
2Types are not all the same
3All types are the same

Here, are_all_same is a variadic template function that uses a fold expression to check if all types in the parameter pack Ts... are the same.

We then have two foo function templates. The first one is enabled if are_all_same<Ts...>() is true, i.e., if all types in Ts... are the same. The second one is enabled if are_all_same<Ts...>() is false.

When we call foo(1, 2, 3), all arguments are of type int, so are_all_same<int, int, int>() is true. Therefore, the first foo template is selected.

When we call foo(1, 2, 3.14), the arguments are of different types (int and double), so are_all_same<int, int, double>() is false. Therefore, the second foo template is selected.

This demonstrates how SFINAE can be used with variadic templates to enable or disable function templates based on properties of the entire parameter pack. This can be a powerful tool for implementing type traits and concepts that depend on variadic templates.