Templates, exception handling and the standard template library notes — Unit 5

Throughout the previous units, C++ enforced strict type checking. An `int` is an `int`, a `float` is a `float`. If you write a function to swap two integers, and later need to swap two floats, you must write a completely new, overloaded function.

The logic `t=a; a=b; b=t;` is completely identical across all three functions. Rewriting the exact same logic just to change the data type violates the DRY (Don't Repeat Yourself) principle. It bloats the codebase and makes maintenance a nightmare.

⇒The Solution: Templates

Templates introduce Generic Programming. They allow you to write a function or a class ONCE, using a placeholder for the data type. The compiler automatically generates the correct type-specific code when you actually use it.

A Function Template acts as a blueprint for generating standard functions. We define a generic type parameter (usually `T`) that the compiler will replace with the actual type at runtime.

⇒How it works: Instantiation

When you call `swapValues(x, y)` where `x` and `y` are integers, the compiler sees the `int` arguments. It silently writes a hidden `int` version of the function into the compiled machine code. If you later call it with `float`, it writes a hidden `float` version.

• Implicit Instantiation: The compiler guesses the type based on the arguments passed: `swapValues(10, 20);`
• Explicit Instantiation: You force the compiler to use a specific type: `swapValues<float>(10.5, 20.5);`

A template is not restricted to a single placeholder type. You can define as many generic types as necessary for your logic.

⇒Template Function Overloading

You can overload a template function with a normal, non-template function. If the compiler finds an EXACT match with the non-template function, it executes that one. If no exact match is found, it instantiates the template.

Just as functions can be generic, entire classes can be generic. This is exceptionally useful for Data Structures. A Stack logic (push, pop, Top) is identical whether it's a Stack of integers, a Stack of floats, or a Stack of custom `Employee` objects.

Template parameters don't always have to be data types. They can also be constant primitive values (usually integers) evaluated at compile-time. These are called Non-Type Template Arguments.

This is vastly superior to dynamic allocation (`new T[size]`) when the size is known beforehand, because the memory is allocated safely on the stack without runtime overhead.

Errors occur in software. Some are syntax errors (caught by the compiler). Some are logical errors (bugs). But Exceptions are anomalous runtime conditions that interrupt the normal flow of the program (e.g., dividing by zero, file not found, memory exhausted).

⇒The C-Style Error Problem

In C, errors were handled by returning error codes (e.g., `-1` for failure). This forced developers to write `if(result == -1)` after EVERY function call, cluttering the code and making it easy to accidentally ignore a critical error.

⇒The C++ Try-Catch Mechanism

C++ separates the error-reporting logic from the error-handling logic using three powerful keywords: `try`, `throw`, and `catch`.

⇒The Unwinding Process

When a `throw` occurs, the system immediately halts the current function. It begins 'Stack Unwinding', destroying all local objects safely (calling their destructors) as it travels back up the call stack looking for a matching `catch` block.

A single `try` block can contain various risky operations that throw completely different types of exceptions (e.g., an `int` error code, a `string` error message, or a custom class). You can chain multiple `catch` blocks to handle each specific type.

In large systems, if you are calling a function written by someone else, you need to know exactly what exceptions it might throw so you can write the correct `catch` blocks. C++ historically provided Exception Specifications.

⇒Modern C++ and 'noexcept'

The old `throw(...)` specifications were deprecated in C++11 because they caused runtime overhead. Modern C++ replaced them entirely with the `noexcept` keyword.

Writing `void myFunc() noexcept;` is an ironclad guarantee to the compiler that the function will never throw. The compiler can drastically optimize the machine code because it doesn't need to generate Stack Unwinding safety nets.

The Standard Template Library (STL) is the crown jewel of C++. It is a massive library of generic, highly optimized templates for data structures and algorithms. Using the STL transforms C++ from a low-level systems language into a highly productive modern language.

⇒The Three Pillars of STL

The genius of the STL is orthogonal design: The algorithms are completely decoupled from the containers. You can use the exact same `std::sort` algorithm to sort a `vector`, a `list`, or a standard array, because the Iterators act as a universal adapter.

Containers physically store your data. They manage memory allocation automatically.

⇒The Almighty Vector

The `std::vector` is a dynamic array. Unlike standard arrays, it automatically resizes itself when you add too many elements.

⇒Iterators

An Iterator behaves exactly like a pointer, but it is smart enough to traverse complex internal structures (like trees or linked lists) using simple `++` operations.

⇒Algorithms

Included via `#include <algorithm>`, these are highly optimized global functions.

A `std::map` is an associative container that stores elements in Key-Value pairs. It automatically sorts the pairs based on the Key using a balanced binary tree (Red-Black Tree) internally.

Maps are universally asked in coding interviews for frequency counting and caching problems.

⇒End-of-Unit Verification

• Explain how Templates implement Generic Programming and solve the DRY principle.
• Write the syntax for a Function Template to swap two generic variables.
• Explain the difference between implicit and explicit template instantiation.
• Write the syntax for a Class Template modeling a generic Stack.
• Explain Non-Type Template Arguments and why they are evaluated at compile-time.
• Explain the separation of logic provided by `try`, `throw`, and `catch` blocks.
• Describe 'Stack Unwinding' during an exception throw.
• Write a multi-catch block, ensuring the 'catch-all' block `catch(...)` is positioned correctly.
• Explain the performance difference between `throw(...)` specifications and the modern `noexcept` keyword.
• List the 3 pillars of the STL and explain how Iterators connect Containers to Algorithms.
• Write a program to create a `vector`, add elements to it, and sort it using `std::sort`.