Interaction between SFINAE and Overloaded Functions

SFINAE interacts with normal function overloading through the overload resolution process. When you call a function, the compiler considers both normal functions and function templates (instantiated with the deduced template arguments) as candidates.

If a function template contains code that would be ill-formed after substituting the deduced arguments, and this code is in a part of the template that undergoes substitution (i.e., the template parameter list, function parameter list, or return type), then a substitution failure occurs. This removes the template from the set of viable candidates, but is not an error.

Consider this example:

1#include <iostream>
2#include <type_traits>
3
4struct A {
5  void foo() { std::cout << "A::foo()\n"; }
6};
7
8struct B {
9  void bar() { std::cout << "B::bar()\n"; }
10};
11
12template <typename T>
13auto call_foo(T t) -> decltype(t.foo()) {
14  t.foo();
15}
16
17void call_foo(B b) {
18  std::cout << "Non-template call_foo(B)\n";
19  b.bar();
20}
21
22int main() {
23  A a;
24
25  // Calls the template, A::foo() is valid
26  call_foo(a);
27
28  B b;
29
30  // Calls the non-template, B::foo() is invalid
31  call_foo(b);
32}

1A::foo()
2Non-template call_foo(B)
3B::bar()

When call_foo(a) is encountered, the template is instantiated with T = A. Since A::foo() is valid, the template is viable and is selected, because it's more specialized than the non-template function.

When call_foo(b) is encountered, the template is instantiated with T = B. This leads to a substitution failure because B does not have a foo() member. However, this is not an error. The template is simply discarded from the overload set, and the non-template call_foo(B) is selected instead.

This demonstrates how SFINAE allows templates to be conditionally removed from overload resolution based on the validity of their instantiation, while still allowing normal overloaded functions to be considered.