In C++ bieden templates een krachtige manier om generieke functies en klassen te schrijven die met verschillende datatypes kunnen werken zonder dat je voor elk datatype aparte code hoeft te schrijven. **Hoe werken templates?** Templates maken gebruik van parameters die je bij het aanmaken van de functie of klasse specificeert. Hierdoor wordt er tijdens de compilatie code gegenereerd voor elk specifiek datatype dat wordt gebruikt. --- ### Voorbeeld van een generieke functie met templates: ```cpp template<typename T> T add(T a, T b) { return a + b; } ``` Deze functie `add` kan nu werken met bijvoorbeeld `int`, `double`, `float`, etc.: ```cpp int main() { int i = add<int>(3, 4); // 7 double d = add<double>(2.5, 3.5); // 6.0 auto result = add(1.2, 3.4); // compilet automatisch als double } ``` **Tip:** - Je kunt de template-parameter ook weglaten en de compiler laten afleiden: ```cpp auto result = add(5, 10); // compiler weet dat het int is ``` --- ### Voorbeeld van een generieke klasse met templates: ```cpp template<typename T> class Container { private: T value; public: Container(T v) : value(v) {} T get() const { return value; } }; ``` Gebruik: ```cpp Container<int> intContainer(5); Container<double> doubleContainer(3.14); ``` --- ### Tips voor het gebruik van templates: 1. **Gebruik `typename` of `class`:** Beide zijn toegestaan bij het specificeren van template parameters, bijvoorbeeld: ```cpp template<class T> // of template<typename T> ``` 2. **Slechte combinaties vermijden:** Sommige types ondersteunen niet de operator `+` (zoals complexe types zonder operator overload). Overweeg het gebruik van concepten (C++20) of SFINAE om te controleren of een type geschikt is. 3. **Template specialisaties:** Soms wil je voor bepaalde types een andere implementatie bieden: ```cpp template<> int add(int a, int b) { // speciale implementatie voor int return a + b; } ``` 4. **Gebruik van concepten (C++20):** Hiermee kun je restricties opleggen aan de template parameters, bijvoorbeeld: ```cpp #include <concepts> template<typename T> requires std::integral<T> T add(T a, T b) { return a + b; } ``` 5. **Code leesbaarheid en debugging:** Templates kunnen complex worden, dus houd je code zo simpel mogelijk en gebruik duidelijke namen. --- ### Samenvatting - Templates maken je code herbruikbaar voor verschillende datatypes. - Definieer een template met `template<typename T>` of `template<class T>`. - Gebruik generieke functies en klassen met deze parameters. - Overweeg specialisaties en concepten voor meer controle. - Laat de compiler type-informatie afleiden wanneer mogelijk. --- Als je meer specifieke voorbeelden of hulp nodig hebt bij je code, stel gerust je vragen!

Je hebt een goede start gemaakt met C++ templates! Hier leg ik uit hoe templates werken, met voorbeelden en tips voor jouw specifieke code. ## Jouw Code: Analyse en Correctie Je code heeft een kleine fout - je definieert de functie twee keer: ```cpp // Goede versie: template<typename T> T add(T a, T b) { return a + b; } ``` ## Uitgebreide Uitleg over Templates ### Basis Template Functie ```cpp template<typename T> // of template<class T> T add(T a, T b) { return a + b; } ``` ### Gebruik in code: ```cpp int main() { int result1 = add(5, 3); // T = int double result2 = add(2.5, 3.7); // T = double std::cout << result1 << ", " << result2; return 0; } ``` ## Klassen Templates ```cpp template<typename T> class Box { private: T content; public: Box(T value) : content(value) {} T getContent() { return content; } void setContent(T value) { content = value; } }; // Gebruik: Box<int> intBox(42); Box<std::string> stringBox("Hallo"); ``` ## Tips voor Template Gebruik ### 1. Meerdere Template Parameters ```cpp template<typename T, typename U> auto multiply(T a, U b) -> decltype(a * b) { return a * b; } ``` ### 2. Specialisatie voor specifieke types ```cpp template<> const char* add(const char* a, const char* b) { // Speciale implementatie voor strings std::string result = std::string(a) + b; return result.c_str(); } ``` ### 3. Type Constraints (C++20) ```cpp template<typename T> requires std::is_arithmetic_v<T> T safeAdd(T a, T b) { return a + b; } ``` ### 4. Template met default parameters ```cpp template<typename T = int> class Container { // T is standaard int }; ``` ## Best Practices 1. **Plaats implementaties in header files** - templates moeten zichtbaar zijn voor de compiler 2. **Gebruik concepten** (C++20) voor betere type checking 3. **Wees voorzichtig met complexe types** - zorg dat alle benodigde operaties zijn gedefinieerd 4. **Documenteer verwachte type-eisen** in comments Je template-functie `add` is een perfect voorbeeld van hoe templates code herbruikbaar en type-veilig maken!