Mi az a SFINAE (Substitution Failure Is Not An Error) a C++-ban?

A SFINAE (Substitution Failure Is Not An Error) egy szabály a C++-ban, amely kimondja, hogy ha a fordító megpróbálja egy sablon argumentumait egy függvény vagy osztály aláírásába behelyettesíteni, és ez a behelyettesítés hibás kódhoz vezet (például egy olyan tag használata, amely nem létezik az adott típushoz), akkor ez nem tekinthető azonnali fordítási hibának. Ehelyett a fordító egyszerűen figyelmen kívül hagyja ezt a sablonpéldányt overload vagy specializáció megoldásakor.

Ez a szabály a fordítási időben történő metaprogramozásra szolgál, lehetővé téve olyan sablonok létrehozását, amelyek viselkedése a sablon argumentumainak tulajdonságaitól függ.

A SFINAE alkalmazásának példái:

• Választás túlterhelt függvények vagy osztály sablonok specializációi között a bizonyos tagok vagy támogatott műveletek megléte alapján.
• Fogalmak (concepts) implementálása (C++20 előtt, amikor megjelentek a kifejezett fogalmak) a sablon típusok korlátozására.
• Típustraits-ek létrehozása.

A std::enable_if-tel való SFINAE használatának példája:

#include <iostream>
#include <type_traits> // A std::enable_if-hez

// Olyan függvény sablon, amely csak egész típusokra fordul le
template <typename T>
typename std::enable_if<std::is_integral<T>::value, void>::type
print_if_integral(T value) {
    std::cout << "Egész típus: " << value << std::endl;
}

// Olyan függvény sablon, amely csak lebegőpontos típusokra fordul le
template <typename T>
typename std::enable_if<std::is_floating_point<T>::value, void>::type
print_if_floating_point(T value) {
    std::cout << "Lebegőpontos típus: " << value << std::endl;
}

int main() {
    print_if_integral(5);       // Az első függvényt hívja
    print_if_floating_point(3.14); // A második függvényt hívja
    // print_if_integral("helló"); // Fordítási hiba - behelyettesítés sikertelen, a függvények figyelmen kívül maradnak

    return 0;
}

Ebben a példában a std::enable_if a visszatérési típusként van használva. Ha a std::is_integral<T>::value igaz, akkor a std::enable_if a void típust adja vissza. Ha hamis, akkor a std::enable_if nem adja meg a type tag-et, ami a függvény aláírásában behelyettesítési hibát eredményez, és a fordító figyelmen kívül hagyja ezt az specializációt.