Tag Dispatching vs SFINAE

Tag dispatching is another technique in C++ for selecting function overloads based on properties of types. While it can often be used to solve similar problems as SFINAE, it works in a different way.

With tag dispatching, you define "tag" types that represent certain properties, and then you overload functions based on these tag types. The selection of the overload happens at the point where you determine which tag to pass to the function.

Here's an example that demonstrates tag dispatching:

1#include <iostream>
2#include <type_traits>
3
4struct integral_tag {};
5struct floating_point_tag {};
6
7template <typename T>
8constexpr auto get_tag() {
9  if constexpr (std::is_integral_v<T>)
10    return integral_tag{};
11  else
12    return floating_point_tag{};
13}
14
15void foo(integral_tag) {
16  std::cout << "foo called with"
17    " an integral type\n";
18}
19
20void foo(floating_point_tag) {
21  std::cout << "foo called with a"
22    " floating point type\n";
23}
24
25template <typename T>
26void bar(T value) {
27  foo(get_tag<T>());
28}
29
30int main() {
31  bar(42);    // Calls foo(integral_tag)
32  bar(3.14);  // Calls foo(floating_point_tag)
33}

1foo called with an integral type
2foo called with a floating point type

Here, integral_tag and floating_point_tag are empty types that serve as "tags". The get_tag function returns an integral_tag if its type argument T is an integral type, and a floating_point_tag otherwise.

We then have two overloads of foo, one accepting an integral_tag and the other accepting a floating_point_tag.

In the bar function template, we call foo with the result of get_tag<T>(). So the selection of which foo overload to call happens at this point, based on the properties of T.

The key differences between tag dispatching and SFINAE are:

1. With SFINAE, the selection happens during overload resolution. The compiler considers all overloads and discards those that would cause substitution failures. With tag dispatching, the selection happens at the point where you choose which tag to pass.
2. SFINAE is a part of the template system and works with types and expressions. Tag dispatching is based on function overloading and works with values (the tags).
3. SFINAE can be used to enable or disable function templates entirely. With tag dispatching, you typically have one main function template that dispatches to different implementations based on the tag.

Both techniques have their uses and can often be used to solve similar problems. Tag dispatching can be more readable in some cases, especially when the conditions for choosing an implementation are complex. However, SFINAE is more flexible and can be used in situations where tag dispatching would be cumbersome or impossible, such as enabling or disabling member functions of class templates.