# Templates in C++ and Their Role in Generic Programming Templates are one of the most powerful features of C++ that support generic programming. They allow programmers to write a single piece of code that can work with different data types without rewriting the same logic for each type. Instead of specifying a particular data type in advance, a template uses a parameter that represents a type. When the program is compiled, the compiler generates the appropriate version of the function or class based on the data type used. Templates therefore improve code reusability, flexibility, maintainability, and type safety. Generic programming is a programming approach in which algorithms and data structures are designed independently of specific data types. C++ templates provide the foundation for this approach. For example, an operation such as finding the larger of two values may be required for integers, floating-point numbers, or characters. Without templates, separate functions would have to be written for each data type. With a template, the same function can be used for all compatible types. A template is defined using the `template` keyword followed by one or more template parameters. A type parameter is commonly declared using `typename` or `class`. Although both keywords can be used for type parameters, they have the same meaning in this context. A simple template declaration has the following general form: ```cpp template return_type function_name(T parameter) { // statements } ``` Here, `T` is a template parameter. It does not represent a specific type until the template is instantiated. The compiler determines the actual type from the arguments supplied to the function or from the template arguments provided by the programmer. Function templates are templates used to create generic functions. A function template defines a general pattern for a function that can operate on different data types. Instead of creating separate functions for integers, doubles, characters, and other types, a single function template can be created. For example: ```cpp #include using namespace std; template T maximum(T a, T b) { return (a > b) ? a : b; } int main() { cout << maximum(10, 20) << endl; cout << maximum(5.5, 3.2) << endl; cout << maximum('A', 'Z') << endl; return 0; } ``` In this example, `T` is a type parameter. When `maximum(10, 20)` is called, the compiler identifies `T` as `int` and generates an appropriate version of the function. When