Templates in C++

C++ templates are a powerful feature that allows us to write generic code. Templates enable us to define functions and classes that can work with different data types. This eliminates the need to write redundant code for each specific data type.

Function Templates

A function template is a blueprint for creating functions that can work with different data types. The syntax for defining a function template is as follows:

1template <typename T>
2return_type function_name(T parameter1, T parameter2, ...) {
3  // function body
4}

In the above syntax, typename T is a placeholder that represents a generic type. It can be replaced with any valid C++ data type.

Let's take a look at an example of a function template that finds the maximum of two values:

1// Function template to find the maximum of two values
2
3template <typename T>
4T max(T a, T b) {
5  return (a > b) ? a : b;
6}

In this example, we define a function template max that takes two parameters of type T and returns the maximum of the two values. The T type is determined at the time of function invocation.

Using Function Templates

To use a function template, we can simply call the function with the appropriate data types as arguments. The compiler will automatically generate the appropriate version of the function for the given data types.

Here's an example of using the max function template with different data types:

1// Using the function template with integer values
2int num1 = 10;
3int num2 = 20;
4int result1 = max(num1, num2);
5
6// Using the function template with floating-point values
7float decimal1 = 3.14;
8float decimal2 = 2.71;
9float result2 = max(decimal1, decimal2);

In this example, we use the max function template to find the maximum of two integers and two floating-point values. The compiler will generate the appropriate version of the max function for each data type.

Class Templates

Similar to function templates, C++ also supports class templates. A class template is a blueprint for creating classes that can work with different data types.

The syntax for defining a class template is similar to that of a regular class. However, we use the typename keyword followed by a generic type placeholder to represent the type of the class members.

1template <typename T>
2class ClassName {
3  // class members
4}

Here's an example of a class template that represents a generic stack:

1// Class template for a generic stack
2
3template <typename T>
4class Stack {
5public:
6  void push(T element);
7  T pop();
8private:
9  // data members
10};

In this example, we define a class template Stack that represents a generic stack. The class can work with any data type represented by the T placeholder.

Using Class Templates

To use a class template, we need to specify the actual data type that will be used with the template. This is done by providing the data type within angle brackets (<>) after the class name.

Here's an example of using the Stack class template with the int data type:

1// Using the Stack class template with the int data type
2Stack<int> intStack;
3intStack.push(10);
4intStack.push(20);
5int poppedElement = intStack.pop();

In this example, we create an instance of the Stack class template with the int data type. We then push two integers onto the stack and pop an element from the stack. The compiler will generate the appropriate version of the Stack class for the int data type.

Benefits of Templates

Templates provide several benefits in C++ programming:

• Code Reusability: Templates allow us to write generic code that can be used with different data types. This promotes code reuse and reduces redundant code.
• Type Safety: Templates provide compile-time type checking, ensuring that the code is used with the correct data types.
• Performance: Templates allow the compiler to generate specialized versions of functions or classes for each data type, resulting in efficient code.

By using templates, we can write flexible and reusable code that can work with different data types without sacrificing performance.

xxxxxxxxxx

#include <iostream>

using namespace std;

​

// Function template to find the maximum of two values

​

template <typename T>

T max(T a, T b) {

  return (a > b) ? a : b;

}

​

int main() {

  // Using the function template with integer values

  int num1 = 10;

  int num2 = 20;

  int result1 = max(num1, num2);

​

  // Using the function template with floating-point values

  float decimal1 = 3.14;

  float decimal2 = 2.71;

  float result2 = max(decimal1, decimal2);

​

  // Output results

  cout << "Maximum of " << num1 << " and " << num2 << " is " << result1 << endl;

  cout << "Maximum of " << decimal1 << " and " << decimal2 << " is " << result2 << endl;

​

  return 0;

}