What is SFINAE?

To begin with, SFINAE is an acronym for:

Substitution F ailure I s N ot A n E rror .

It could be translated as FESNEUE or FASNEUE:

F alloit I n Substitution Is Not A E rror . _ _ _

F alloit A l Substitute Is Not A E rror . _ _ _

For the RAE an acronym is written in capital letters if it is necessary to spell it:

2.7. Acronyms and acronyms

Initials and acronyms whose frequency of use has given them a defined grammatical character -masculine or feminine nouns, for example-, are listed as normal entries (eg, radar), or in capital letters when, as a general rule, it is necessary to spell them (DNA).

Since it can be read normally (even the English version) I (personally) would write it as if it were a normal word, so let's answer the question...

What is sfinae (fesneue/fasneue)?

This is a curioustemplate feature of how C++ templates ( ) work. This feature tells us that failing to substitute a template parameter does not have to be an error .

To understand this operation, we can see what happens with a simple template:

template <typename T, typename U>
T plantilla(U u) { return static_cast<T>(u); }

When we use the above template, the template goes through an instantiation process , one of the first steps is to substitute the generic parameters ( Tand Uin the example) with the provided (or inferred) parameters:

Substitute.

std::cout << plantilla<int, float>(123.456) << '\n';

In this instantiation of plantillaa function is created like this:

   int plantilla(float u) { return static_cast<int>(u); }
// ^^^           ^^^^^                         ^^^
//  T              U                            T

The generic parameter Thas been replaced with intwhile Uhas been replaced with floatand will print 123to the console.

Fail!.

If we change plantillaas follows:

template <typename T, typename U>
T plantilla(typename U::value_type u) { return static_cast<T>(u); }
//          ^^^^^^^^  ^^^^^^^^^^^^ <--- referencia sub-tipo en U

When making the previous call the resulting substitution will be:

   int plantilla(typename float::value_type u) { return static_cast<int>(u); }
// ^^^                    ^^^^^                                     ^^^
//  T                       U                                        T

Since the type floatdoes not have a subtype value_type, the substitution fails with an error.

Do not fail!.

But if we had both functions:

template <typename T, typename U>
T plantilla(typename U::value_type u) { return static_cast<T>(u); }

template <typename T, typename U>
T plantilla(U u) { return static_cast<T>(u); }

When instantiating the template we would have a version that fails and another that does not:

std::cout << plantilla<int, float>(123.456) << '\n';

// Fallo!
int plantilla(typename float::value_type u) { return static_cast<int>(u); }
// Correcto!
int plantilla(float u) { return static_cast<int>(u); }

In this case, the compiler instantiates all the templates and tries to substitute all the parameters, if after the substitution there is one (and only one) valid version of the template then it will not produce an error.

That is to say, in this case we have been able to see that a F allo w to Substitute Is N o t an E rror .

Okay, I understood but... what is it for?

The fasneue behavior is in the nature of C++ templates. Templates were designed this way to solve other problems (such as causing unexpected errors when including templates from third-party libraries) but some C++ programmers saw additional potential in this behavior, as it allows rudimentary compile-time type introspection.

For example, if we have a function that we want to act differently depending on whether it is called with integers or floating point numbers:

void f(int)   { std::cout << "int\n"; }
void f(float) { std::cout << "float\n"; }

Calling it with a type other than into floatwould fail due to ambiguity:

f(1u); // ERROR! Convierto unsigned int a int o a float?
f(.1); // ERROR! Convierto double a int o a float?

A possible solution would be to create overloads for all types:

void f(char)               { std::cout << "entero\n"; }
void f(unsigned char)      { std::cout << "entero\n"; }
void f(signed char)        { std::cout << "entero\n"; }
void f(short)              { std::cout << "entero\n"; }
void f(unsigned short)     { std::cout << "entero\n"; }
void f(int)                { std::cout << "entero\n"; }
void f(unsigned int)       { std::cout << "entero\n"; }
void f(long)               { std::cout << "entero\n"; }
void f(unsigned long)      { std::cout << "entero\n"; }
void f(long long)          { std::cout << "entero\n"; }
void f(unsigned long long) { std::cout << "entero\n"; }
void f(float)              { std::cout << "flotante\n"; }
void f(double)             { std::cout << "flotante\n"; }
void f(long double)        { std::cout << "flotante\n"; }

It is a hassle to create 14 functions almost all the same with repeated code, but with fesneue we can separate these functions into integer and float:

template<class T, typename std::enable_if_t<std::is_integral_v<T>>* = nullptr>
void f(T) { std::cout << "entero\n"; }
template<class T, typename std::enable_if_t<std::is_floating_point_v<T>>* = nullptr>
void f(T) { std::cout << "flotante\n"; }

The two previous template functions allow us to discern if the received type is an integer or floating point value with only two versions of the function, using other templates to achieve this:

type characteristics <type_traits>.

This library offers templates that allow types to be interrogated to find out if they meet certain characteristics, apart from the " Is the type integer? " and " Is the type floating point? " that we have already seen, it can be used to check whether the type is a pointer, a class, or a function. All of these called templates is_xxxxresult in a boolean value (computed at compile time) with a value of true if the check passes.

Conditional fesneue<std::enable_if>

The template std::enable_ifis an object that, if the condition received as the first parameter is met, will contain the type provided as the second template parameter; otherwise it will be an empty object.

Knowing this, the last example would work as follows:

template<class T, typename std::enable_if_t<std::is_integral_v<T>>* = nullptr>
void f(T) { std::cout << "entero\n"; }
template<class T, typename std::enable_if_t<std::is_floating_point_v<T>>* = nullptr>
void f(T) { std::cout << "flotante\n"; }

f(1u); // Muestra 'entero'
f(.1); // Muestra 'flotante'

In the substitution phase, using the unsigned integer literal the following would happen:

• std::is_integral_v<unsigned int>is replaced by true.
• std::enable_if_t<unsigned int, true>is replaced by unsigned int.
• The function fremains as f(unsigned int).
• std::is_floating_point_v<double>is replaced by false.
• std::enable_if_t<double, false>is replaced by nothing.
• The substitution fails.
• The first version of the function is chosen as valid.

In the second case, the substitution that fails is the first one and the second version of the function fthat has not failed the substitution is chosen.