Template metaprogrammering in C++ stelt je in staat om berekeningen en generieke code al tijdens de compilatie uit te voeren. Hierdoor kun je efficiëntere code genereren en compile-tijd controles uitvoeren. Hieronder leg ik uit hoe je dit effectief kunt toepassen met voorbeelden, inclusief template specialisatie, variadische templates en SFINAE. 1. Template specialisatie ------------------------- Met speciale templates kun je specifieke gevallen afhandelen, zoals basisgevallen in recursieve berekeningen. Voorbeeld: Berekenen van factorialen op compile-tijd ```cpp // Algemene template voor factorial template<int N> struct Factorial { static constexpr int value = N * Factorial<N - 1>::value; }; // Specialisatie voor N=0 template<> struct Factorial<0> { static constexpr int value = 1; }; ``` Gebruik: ```cpp constexpr int fact5 = Factorial<5>::value; // 120 ``` Hier wordt de berekening tijdens het compileren uitgevoerd, wat de runtime-prestaties verbetert. 2. Variadische templates ------------------------- Met variadische templates kun je functies en structs schrijven die met een willekeurig aantal template-parameters werken. Voorbeeld: Som van een lijst van getallen op compile-tijd ```cpp // Basisgeval: geen parameters, som is 0 template<> struct Sum<> { static constexpr int value = 0; }; // Recursieve case template<typename T, typename... Rest> struct Sum<T, Rest...> { static constexpr int value = T::value + Sum<Rest...>::value; }; ``` Gebruik: ```cpp struct One { static constexpr int value = 1; }; struct Two { static constexpr int value = 2; }; struct Three { static constexpr int value = 3; }; constexpr int total = Sum<One, Two, Three>::value; // 6 ``` 3. SFINAE (Substitution Failure Is Not An Error) ---------------------------------------------- SFINAE stelt je in staat om functies of templates te activeren/deactiveren afhankelijk van bepaalde voorwaarden, bijvoorbeeld typeeigenschappen. Voorbeeld: Compile-tijd check of type iterabel is ```cpp #include <type_traits> template<typename T> auto print_if_iterable(const T& container) -> decltype(std::begin(container), void()) { for (auto& item : container) { // doe iets } } ``` Hier wordt `print_if_iterable` alleen gecompileerd als `container` een begin iterator heeft. Als niet, wordt het overgeslagen zonder compileerfout. Samenvatting ------------ - Gebruik template specialisatie voor basisgevallen en specifieke optimalisaties. - Gebruik variadische templates voor generieke en flexibele code voor meerdere parameters. - Gebruik SFINAE om functies of templates conditioneel te activeren op compile-tijd, afhankelijk van typeeigenschappen. Door deze technieken te combineren, kun je zeer efficiënte en flexibele code schrijven die zoveel mogelijk op compile-tijd afhandelt, wat resulteert in snellere en betrouwbaardere programma's.

Hier is een uitleg over template metaprogrammering in C++ met de gevraagde technieken: ## Template Specialisatie (zoals in uw voorbeeld) Uw factorial-voorbeeld demonstreert perfect template specialisatie: ```cpp // Primaire template template<int N> struct Factorial { static constexpr int value = N * Factorial<N-1>::value; }; // Volledige specialisatie voor basisgeval template<> struct Factorial<0> { static constexpr int value = 1; }; // Gebruik: static_assert(Factorial<5>::value == 120, "Factorial van 5 moet 120 zijn"); ``` ## Variadische Templates Voor het werken met variabele aantallen template-argumenten: ```cpp // Basisgeval: lege lijst template<typename... Args> struct CountTypes { static constexpr int value = 0; }; // Recursief geval: pak eerste type, verwerk rest template<typename T, typename... Rest> struct CountTypes<T, Rest...> { static constexpr int value = 1 + CountTypes<Rest...>::value; }; // Gebruik: static_assert(CountTypes<int, double, char>::value == 3, "Moet 3 types tellen"); ``` ## SFINAE (Substitution Failure Is Not An Error) Voor conditionele compilatie op basis van type-eigenschappen: ```cpp #include <type_traits> // Alleen beschikbaar voor integrale types template<typename T> typename std::enable_if<std::is_integral<T>::value, T>::type multiply(T a, T b) { return a * b; } // Alleen beschikbaar voor floating-point types template<typename T> typename std::enable_if<std::is_floating_point<T>::value, T>::type multiply(T a, T b) { return a * b * 1.1; // Andere implementatie } // Moderne C++17/20 syntax met if constexpr template<typename T> auto better_multiply(T a, T b) { if constexpr (std::is_integral_v<T>) { return a * b; } else if constexpr (std::is_floating_point_v<T>) { return a * b * 1.1; } else { static_assert(false, "Type niet ondersteund"); } } ``` ## Praktisch Voorbeeld: Type List Manipulatie ```cpp template<typename... Types> struct TypeList {}; // Controleer of type in lijst zit template<typename T, typename... List> struct Contains; template<typename T> struct Contains<T> : std::false_type {}; template<typename T, typename First, typename... Rest> struct Contains<T, First, Rest...> : std::conditional_t<std::is_same_v<T, First>, std::true_type, Contains<T, Rest...>> {}; // Gebruik: using MyTypes = TypeList<int, double, char>; static_assert(Contains<int, int, double, char>::value, "int moet in lijst zitten"); ``` ## Compile-time Fibonacci ```cpp template<int N> struct Fibonacci { static constexpr int value = Fibonacci<N-1>::value + Fibonacci<N-2>::value; }; template<> struct Fibonacci<0> { static constexpr int value = 0; }; template<> struct Fibonacci<1> { static constexpr int value = 1; }; static_assert(Fibonacci<10>::value == 55, "Fibonacci(10) moet 55 zijn"); ``` ## Belangrijke Tips: 1. **constexpr functions** (C++11+) zijn vaak eenvoudiger dan template metaprogrammering 2. Gebruik **static_assert** voor compile-time validatie 3. **if constexpr** (C++17) maakt conditionele code veel leesbaarder 4. **Concepts** (C++20) vervangen veel SFINAE-use cases Uw factorial-implementatie is een klassiek en correct voorbeeld van template metaprogrammering!