Substitution failure is not an error

<h2 id="example">Example</h2>
<p>The following example illustrates a basic instance of SFINAE:
</p>
struct Test {
  typedef int foo;
};

template <typename T>
void f(typename T::foo) {}  // Definition #1

template <typename T>
void f(T) {}  // Definition #2

int main() {
  f<Test>(10);  // Call #1.
  f<int>(10);   // Call #2. Without error (even though there is no int::foo)
                // thanks to SFINAE.
  return 0;
}

<p>Here, attempting to use a non-class type in a qualified name (T::foo) results in a deduction failure for f<int> because int has no nested type named foo, but the program is well-formed because a valid function remains in the set of candidate functions.
</p><p>Although SFINAE was initially introduced to avoid creating ill-formed programs when unrelated template declarations were visible (e.g., through the inclusion of a header file), many developers later found the behavior useful for compile-time introspection. Specifically, it allows a template to determine certain properties of its template arguments at instantiation time.
</p><p>For example, SFINAE can be used to determine if a type contains a certain typedef:
</p>
#include <iostream>

template <typename T>
struct has_typedef_foobar {
  // Types "yes" and "no" are guaranteed to have different sizes,
  // specifically sizeof(yes) == 1 and sizeof(no) == 2.
  typedef char yes[1];
  typedef char no[2];

template <typename C>
  static yes& test(typename C::foobar*);

template <typename>
  static no& test(...);

// If the "sizeof" of the result of calling test<T>(nullptr) is equal to
  // sizeof(yes), the first overload worked and T has a nested type named
  // foobar.
  static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
};

struct foo {
  typedef float foobar;
};

int main() {
  std::cout << std::boolalpha;
  std::cout << has_typedef_foobar<int>::value << std::endl;  // Prints false
  std::cout << has_typedef_foobar<foo>::value << std::endl;  // Prints true
  return 0;
}

<p>When T has the nested type foobar defined, the instantiation of the first test works and the null pointer constant is successfully passed. (And the resulting type of the expression is yes.) If it does not work, the only available function is the second test, and the resulting type of the expression is no. An ellipsis is used not only because it will accept any argument, but also because its conversion rank is lowest, so a call to the first function will be preferred if it is possible; this removes ambiguity.
</p>
<h2 id="c11-simplification">C++11 simplification</h2>
<p>In <a href="/facts/C%2B%2B11/fI3YCoKQ">C++11</a>, the above code could be simplified to:
</p>
#include <iostream>
#include <type_traits>

template <typename... Ts>
using void_t = void;

template <typename T, typename = void>
struct has_typedef_foobar : std::false_type {};

template <typename T>
struct has_typedef_foobar<T, void_t<typename T::foobar>> : std::true_type {};

struct foo {
  using foobar = float;
};

int main() {
  std::cout << std::boolalpha;
  std::cout << has_typedef_foobar<int>::value << std::endl;
  std::cout << has_typedef_foobar<foo>::value << std::endl;
  return 0;
}

<p>With the standardisation of the detection idiom in the <a href="http://en.cppreference.com/w/cpp/experimental/lib_extensions_2">Library fundamental v2 (n4562)</a> proposal, the above code could be re-written as follows:
</p>
#include <iostream>
#include <type_traits>

template <typename T>
using has_typedef_foobar_t = typename T::foobar;

struct foo {
  using foobar = float;
};

int main() {
  std::cout << std::boolalpha;
  std::cout << std::is_detected<has_typedef_foobar_t, int>::value << std::endl;
  std::cout << std::is_detected<has_typedef_foobar_t, foo>::value << std::endl;
  return 0;
}

<p>The developers of <a href="/facts/Boost_C%2B%2B_Libraries/vGLGG51A">Boost</a> used SFINAE in boost::enable_if<a class="footnote-ref" id="fnref:3" href="#fn:3"><sup>3</sup></a> and in other ways.
</p>

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>Vandevoorde, David; Nicolai M. Josuttis (2002). C++ Templates: The Complete Guide. Addison-Wesley Professional. ISBN 0-201-73484-2. <a href="0-201-73484-2" target="_blank">0-201-73484-2</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>International Organization for Standardization. "ISO/IEC 14882:2003, Programming languages – C++", § 14.8.2. <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>Boost Enable If <a href="http://www.boost.org/doc/libs/release/libs/utility/enable_if.html" target="_blank">http://www.boost.org/doc/libs/release/libs/utility/enable_if.html</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
</ol>

Substitution failure is not an error open-in-new

Substitution failure is not an error