Function and Class Templates

In C++, Templates provide a mechanism for generic programming. Instead of writing the exact same code multiple times for int, float, and string, you can write it once as a template. The compiler will automatically generate the correct version for you when the code is used.

1. Function Templates

Suppose you want to write a function that finds the maximum of two numbers. Without templates, you would have to use function overloading for every data type:

cpp

int max_val(int a, int b) { return (a > b) ? a : b; }
double max_val(double a, double b) { return (a > b) ? a : b; }
// ... and so on for float, char, etc.

With Function Templates, you define a placeholder type (often called T), and the compiler does the rest.

Syntax

cpp

#include <iostream>
using namespace std;
 
// The template prefix declares 'T' as a generic type
template <typename T>
T findMax(T x, T y) {
    return (x > y) ? x : y;
}
 
int main() {
    // The compiler automatically creates an int version
    cout << findMax<int>(10, 5) << endl;       
 
    // The compiler automatically creates a double version
    cout << findMax<double>(3.14, 9.81) << endl; 
 
    // Type inference: you don't even need the <type> brackets!

2. Class Templates

Just like functions, classes can also be templates. This is exceptionally useful for creating data structures (like Stacks, Queues, and Linked Lists) that can hold any type of data.

cpp

#include <iostream>
using namespace std;
 
// A generic Box class that can hold any type of data
template <class T>
class Box {
private:
    T contents;
public:
    Box(T initial_val) {
        contents = initial_val;
    }
    
    T getContents() {
        return contents;
    }
};
 
int main() {
    // We must specify the type when instantiating a class template
    Box<int> intBox(100);
    Box<string> stringBox("Hello Templates!");
 
    cout <<

3. How Templates Work

When you write a template, you are not writing an actual function or class; you are writing a blueprint for one.

When the compiler encounters findMax<int>(10, 5), it looks at the template and generates a hidden int version of the function in the background. If you never call the template with a float, a float version is never compiled. This process is called Template Instantiation.

Summary

Templates allow you to write generic, type-independent code.
Function Templates replace the need for massive function overloading.
Class Templates are ideal for creating generic data structures.
The compiler handles the generation of specific types at compile-time (instantiation).

Assessed progress

Function and Class Templates

Function and Class Templates

1. Function Templates

Syntax

2. Class Templates

3. How Templates Work

Summary

Key Concepts

Templates

Function Templates

Class Templates

Quick Check

Object Oriented Programming

Object Oriented Programming