{"id":951,"date":"2025-06-10T12:42:25","date_gmt":"2025-06-10T09:42:25","guid":{"rendered":"https:\/\/www.certbolt.com\/certification\/?p=951"},"modified":"2025-12-31T14:15:12","modified_gmt":"2025-12-31T11:15:12","slug":"demystifying-templates-in-c","status":"publish","type":"post","link":"https:\/\/www.certbolt.com\/certification\/demystifying-templates-in-c\/","title":{"rendered":"Demystifying Templates in C++"},"content":{"rendered":"

Templates in C++ serve as the cornerstone of generic programming. They allow programmers to create functions and classes that operate with any data type. Rather than duplicating code for each data type, templates offer a single definition that works with various types. This significantly reduces code redundancy and enhances code maintainability. Templates enable a developer to write more flexible and reusable code. When a template is instantiated, the compiler generates the appropriate function or class by replacing the generic type with the actual data type provided.<\/span><\/p>\n

The Need for Templates<\/b><\/p>\n

In traditional programming, different data types require separate functions or classes even if the underlying logic is the same. For instance, sorting integers, floats, or strings would typically need separate functions. Templates overcome this issue by generalizing the code structure. This capability is invaluable in scenarios where the same algorithm needs to be implemented across multiple data types. Templates streamline development and lead to cleaner and more consistent code.<\/span><\/p>\n

Basic Syntax of Templates<\/b><\/p>\n

C++ templates use the keyword <\/span>template<\/span> followed by template parameters enclosed in angle brackets. These parameters typically use the <\/span>typename<\/span> or <\/span>class<\/span> keyword to denote generic types. Here is the basic syntax for a function template:<\/span><\/p>\n

template <class T><\/span><\/p>\n

T functionName(T arg1, T arg2) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ function body<\/span><\/p>\n

}<\/span><\/p>\n

Similarly, the syntax for a class template is:<\/span><\/p>\n

template <typename T><\/span><\/p>\n

class ClassName {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ class body<\/span><\/p>\n

};<\/span><\/p>\n

The <\/span>typename<\/span> and <\/span>class<\/span> keywords are interchangeable, although <\/span>typename<\/span> is more commonly used in modern C++.<\/span><\/p>\n

Function Templates in Detail<\/b><\/p>\n

Function templates enable functions to work with generic types. When a function template is called with specific types, the compiler generates a version of the function with those types. This is known as template instantiation. Consider the following example that returns the maximum of two values:<\/span><\/p>\n

template <class T><\/span><\/p>\n

T MaxVal(T a, T b) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0return (a > b)? a: b;<\/span><\/p>\n

}<\/span><\/p>\n

In this example, the function can work with integers, floats, or characters. When <\/span>MaxVal<int>(5, 10)<\/span> is called, the compiler generates a version of <\/span>MaxVal<\/span> specifically for integers. This approach eliminates the need for multiple overloaded functions.<\/span><\/p>\n

Example: Function Template Usage<\/b><\/p>\n

#include <iostream><\/span><\/p>\n

using namespace std;<\/span><\/p>\n

template <class T><\/span><\/p>\n

T MaxVal(T a, T b) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0return (a > b) a: b;<\/span><\/p>\n

}<\/span><\/p>\n

int main() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0cout << MaxVal<int>(5, 8) << endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0cout << MaxVal<double>(6.5, 4.0) << endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0cout << MaxVal<char>(‘f’, ‘k’) << endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

}<\/span><\/p>\n

This program demonstrates how one function can be used across multiple data types, simplifying the implementation and improving code readability.<\/span><\/p>\n

Advantages of Function Templates<\/b><\/p>\n

Function templates offer several advantages:<\/span><\/p>\n

They reduce code duplication.<\/span>
\n<\/span> They simplify maintenance<\/span>
\n<\/span> They make code more readable and expressive.e<\/span>
\n<\/span> They enable type safety during compilation.on<\/span>
\n<\/span> Templates are particularly useful in libraries where generic data manipulation is needed.<\/span><\/p>\n

Class Templates in Detail<\/b><\/p>\n

Class templates allow the definition of classes that can operate with any data type. This is especially useful for creating container classes like arrays, lists, and stacks that should handle various types. A class template is defined similarly to a function template but applies to an entire class:<\/span><\/p>\n

template <class T><\/span><\/p>\n

class Array {<\/span><\/p>\n

Private:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0T* data;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0int size;<\/span><\/p>\n

Public:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Array(T arr[], int s) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0data = new T[s];<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0size = s;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0for (int i = 0; i < size; ++i)<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0data[i] = arr[i];<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0void print() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0for (int i = 0; i < size; ++i)<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0cout << data[i] << » «;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0cout << endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

};<\/span><\/p>\n

This class can be instantiated with any data type, such as int, float, or custom classes.<\/span><\/p>\n

Example: Class Template Usage<\/b><\/p>\n

#include <iostream><\/span><\/p>\n

using namespace std;<\/span><\/p>\n

template <class T><\/span><\/p>\n

class Array {<\/span><\/p>\n

private:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0T* pointr;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0int size;<\/span><\/p>\n

Public:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Array(T arr[], int s) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0pointr = new T[s];<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0size = s;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0for (int i = 0; i < size; i++)<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0pointr[i] = arr[i];<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0void print() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0for (int i = 0; i < size; i++)<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0cout << pointr[i] << » «;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0cout << endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

};<\/span><\/p>\n

int main() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0int arr[5] = {1, 2, 3, 4, 5};<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Array<int> a(arr, 5);<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0a.print();<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

}<\/span><\/p>\n

The above example shows a class that stores and prints an array. The same class can be used for any data type.<\/span><\/p>\n

Advantages of Class Templates<\/b><\/p>\n

Class templates enhance flexibility and reusability<\/span>
\n<\/span> They provide strong type-checking at compile time<\/span>
\n<\/span> They facilitate the development of a generic container<\/span>
\n<\/span> Templates encourage writing abstract, generalized code<\/span>
\n<\/span> Class templates are foundational in building libraries like the Standard Template Library (STL)<\/span><\/p>\n

How Templates Work at Compile Time<\/b><\/p>\n

Templates are expanded at compile time through a process called template instantiation. When the compiler encounters a function or class template call with a specific type, it generates the corresponding function or class definition. Unlike macros, templates support type checking, which ensures that only valid types are used. This leads to safer and more robust code.<\/span><\/p>\n

Template Parameters<\/b><\/p>\n

Templates can accept different types of parameters:<\/span><\/p>\n

Type parameters: the most common, specified using <\/span>typename<\/span> or <\/span>class<\/span>
\n<\/span> Non-type parameters, such as integers or characters, which are useful for fixed-size arrays<\/span>
\n<\/span> Template template parameters: allow templates to accept other templates as arguments<\/span><\/p>\n

Example of non-type parameter:<\/span><\/p>\n

template <class T, int size><\/span><\/p>\n

class FixedArray {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0T arr[size];<\/span><\/p>\n

};<\/span><\/p>\n

This creates a fixed-size array of a specified data type and size.<\/span><\/p>\n

Template Specialization in C++<\/b><\/p>\n

Template specialization in C++ allows the programmer to provide a specific implementation of a template when a particular data type is used. While generic templates provide a generalized solution, there are situations where specific types need a tailored approach. Template specialization addresses this by allowing a unique definition for specific data types while maintaining the general template structure for others.<\/span><\/p>\n

Why Use Template Specialization<\/b><\/p>\n

There are cases where generic behavior does not meet all requirements. For example, a class that prints elements of different types might need to handle strings differently from integers or floats. In such scenarios, template specialization allows for fine-tuning the behavior of the template for specific types, providing more control and enhancing the flexibility of the code.<\/span><\/p>\n

Syntax of Template Specialization<\/b><\/p>\n

Template specialization is declared using the same template name but specifies the data type for which the specialized implementation is intended. Below is the syntax for template specialization:<\/span><\/p>\n

template <><\/span><\/p>\n

void functionName<int>(int arg) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ specialized implementation for int<\/span><\/p>\n

}<\/span><\/p>\n

This tells the compiler to use this version of the function when the data type is <\/span>int<\/span>.<\/span><\/p>\n

Example: Function Template Specialization<\/b><\/p>\n

#include <iostream><\/span><\/p>\n

using namespace std;<\/span><\/p>\n

template <typename T><\/span><\/p>\n

void display(T value) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0cout << «Generic template: » << value << endl;<\/span><\/p>\n

}<\/span><\/p>\n

template <><\/span><\/p>\n

void display<int>(int value) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0cout << «Specialized template for int: » << value << endl;<\/span><\/p>\n

}<\/span><\/p>\n

int main() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0display(10);\u00a0 \u00a0 \u00a0 \u00a0 \/\/ uses specialized version<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0display(‘A’); \u00a0 \u00a0 \u00a0 \/\/ uses generic version<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0display(5.5); \u00a0 \u00a0 \u00a0 \/\/ uses generic version<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

}<\/span><\/p>\n

This code demonstrates how <\/span>display<int><\/span> is treated differently due to specialization.<\/span><\/p>\n

Class Template Specialization<\/b><\/p>\n

Similar to functions, class templates can also be specialized. Class template specialization is useful when a particular data type needs a distinct class behavior or structure. Below is the general syntax:<\/span><\/p>\n

template <><\/span><\/p>\n

class ClassName<int> {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ specialized implementation for int<\/span><\/p>\n

};<\/span><\/p>\n

Example: Class Template Specialization<\/b><\/p>\n

#include <iostream><\/span><\/p>\n

using namespace std;<\/span><\/p>\n

template <typename T><\/span><\/p>\n

class Printer {<\/span><\/p>\n

public:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0void print(T value) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0cout << «Generic print: » << value << endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

};<\/span><\/p>\n

template <><\/span><\/p>\n

class Printer<string> {<\/span><\/p>\n

public:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0void print(string value) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0cout << «String print: » << value << endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

};<\/span><\/p>\n

int main() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Printer<int> p1;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0p1.print(100);<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Printer<string> p2;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0p2.print(«Hello»);<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

}<\/span><\/p>\n

This example shows how the <\/span>Printer<\/span> class behaves differently for <\/span>string<\/span> types.<\/span><\/p>\n

Partial Specialization<\/b><\/p>\n

C++ also supports partial specialization of class templates. Partial specialization allows customizing certain parts of the template while retaining the generic nature for other parts. It provides a middle ground between full specialization and full generalization.<\/span><\/p>\n

Syntax of Partial Specialization<\/b><\/p>\n

Partial specialization is defined by specifying only some of the template parameters:<\/span><\/p>\n

template <typename T, typename U><\/span><\/p>\n

class Container {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ generic definition<\/span><\/p>\n

};<\/span><\/p>\n

template <typename T><\/span><\/p>\n

class Container<T, int> {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ partially specialized definition for the second type as int<\/span><\/p>\n

};<\/span><\/p>\n

Example: Partial Specialization<\/b><\/p>\n

#include <iostream><\/span><\/p>\n

using namespace std;<\/span><\/p>\n

template <typename T, typename U><\/span><\/p>\n

class Container {<\/span><\/p>\n

public:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0void display() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0cout << «Generic Container» << endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

};<\/span><\/p>\n

template <typename T><\/span><\/p>\n

class Container<T, int> {<\/span><\/p>\n

public:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0void display() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0cout << «Partial specialization where second type is int» << endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

};<\/span><\/p>\n

int main() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Container<float, char> c1;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0c1.display();<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Container<float, int> c2;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0c2.display();<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

}<\/span><\/p>\n

This example illustrates how partial specialization is used when only some template parameters need customization.<\/span><\/p>\n

Multiple Template Parameters<\/b><\/p>\n

Declaring Multiple Parameters<\/b><\/p>\n

Templates in C++ are not limited to a single parameter. You can pass multiple parameters to a template to handle complex data or mixed types. This allows the creation of more versatile and flexible templates.<\/span><\/p>\n

Syntax for Multiple Parameters<\/b><\/p>\n

template <typename T, typename U><\/span><\/p>\n

class ClassName {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ class body<\/span><\/p>\n

};<\/span><\/p>\n

This syntax indicates that the class or function works with two different data types.<\/span><\/p>\n

Example: Template with Two Parameters<\/b><\/p>\n

#include <iostream><\/span><\/p>\n

using namespace std;<\/span><\/p>\n

template <class T, class U><\/span><\/p>\n

class Pair {<\/span><\/p>\n

private:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0T first;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0U second;<\/span><\/p>\n

Public:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Pair(T f, U s) : first(f), second(s) {}<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0void show() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0cout << «First: » << first << «, Second: » << second << endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

};<\/span><\/p>\n

int main() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Pair<int, double> obj1(10, 15.75);<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0obj1.show();<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Pair<string, char> obj2(«Text», ‘A’);<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0obj2.show();<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

}<\/span><\/p>\n

This example demonstrates how a class can be made more functional by supporting multiple data types.<\/span><\/p>\n

Default Template Arguments<\/b><\/p>\n

Like functions, templates in C++ can have default arguments. This provides more flexibility, allowing the template to be used with or without specifying all the arguments. If an argument is not provided, the default value is used.<\/span><\/p>\n

Syntax for Default Arguments<\/b><\/p>\n

template <typename T, typename U = char><\/span><\/p>\n

class Sample {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ class body<\/span><\/p>\n

};<\/span><\/p>\n

Here, <\/span>U<\/span> will default to <\/span>char<\/span> if not specified.<\/span><\/p>\n

Example: Using Default Arguments<\/b><\/p>\n

#include <iostream><\/span><\/p>\n

using namespace std;<\/span><\/p>\n

template <typename T, typename U = char><\/span><\/p>\n

class Example {<\/span><\/p>\n

public:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0T x;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0U y;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Example() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0cout << «Constructor Called» << endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

};<\/span><\/p>\n

int main() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Example<int> obj1;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Example<int, float> obj2;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

}<\/span><\/p>\n

In this case, <\/span>obj1<\/span> uses <\/span>int<\/span> and defaults <\/span>U<\/span> to <\/span>char<\/span>, while <\/span>obj2<\/span> explicitly uses both <\/span>int<\/span> and <\/span>float<\/span>.<\/span><\/p>\n

Templates vs Function Overloading<\/b><\/p>\n

Templates and function overloading both support polymorphism in C++, but they serve different purposes. Function overloading is used when the logic is similar but needs tailored implementations for different types. Templates are best when the logic is identical across types.<\/span><\/p>\n

Function Overloading<\/b><\/p>\n

Function overloading involves creating multiple functions with the same name but different parameter lists:<\/span><\/p>\n

void print(int a) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0cout << a << endl;<\/span><\/p>\n

}<\/span><\/p>\n

void print(double b) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0cout << b << endl;<\/span><\/p>\n

}<\/span><\/p>\n

This method provides control, but can become verbose when dealing with many types.<\/span><\/p>\n

Templates for Polymorphism<\/b><\/p>\n

Templates allow a single function to handle multiple types:<\/span><\/p>\n

template <typename T><\/span><\/p>\n

void print(T value) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0cout << value << endl;<\/span><\/p>\n

}<\/span><\/p>\n

This approach reduces code duplication and is easier to maintain.<\/span><\/p>\n

Choosing Between the Two<\/b><\/p>\n

Use templates when the function logic is truly generic<\/span>
\n<\/span> Use function overloading when different types require distinct logic<\/span><\/p>\n

Templates are more suitable for libraries and generic data structures, while overloading is better for small, type-specific customizations.<\/span><\/p>\n

Template Metaprogramming in C++<\/b><\/p>\n

Template metaprogramming (TMP) is a powerful technique in C++ where templates are used to perform computations at compile time rather than at runtime. This approach leverages the compiler’s template instantiation mechanism to execute code during compilation, enabling optimizations and complex code generation before the program runs.<\/span><\/p>\n

TMP allows developers to write code that can generate other code or make decisions at compile time, improving performance and enabling static checks that would otherwise require runtime overhead.<\/span><\/p>\n

Why Use Template Metaprogramming?<\/b><\/p>\n

Using template metaprogramming can improve performance by eliminating calculations during runtime and catching errors early during compilation. It enables the creation of highly generic and optimized libraries and supports advanced techniques such as static assertions, conditional compilation, and type manipulation.<\/span><\/p>\n

Common use cases include calculating factorials or Fibonacci numbers, type traits for detecting properties of types, and implementing compile-time lists or algorithms.<\/span><\/p>\n

Basic Example: Compile-Time Factorial Calculation<\/b><\/p>\n

#include <iostream><\/span><\/p>\n

using namespace std;<\/span><\/p>\n

template <int N><\/span><\/p>\n

struct Factorial {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0static const int value = N * Factorial<N — 1>::value;<\/span><\/p>\n

};<\/span><\/p>\n

template <><\/span><\/p>\n

struct Factorial<0> {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0static const int value = 1;<\/span><\/p>\n

};<\/span><\/p>\n

int main() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0cout << «Factorial of 5 is: » << Factorial<5>::value << endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

}<\/span><\/p>\n

In this example, the factorial of 5 is computed entirely at compile time using recursive template instantiation.<\/span><\/p>\n

How Template Metaprogramming Works<\/b><\/p>\n

TMP uses recursive templates where each instantiation processes part of the computation and passes control to a specialized or base case template. This recursion unfolds during compilation, and the final computed value is made available through static members or constexpr variables.<\/span><\/p>\n

Advantages and Limitations of TMP<\/b><\/p>\n