Templates and Exception Handling: Function/Class Templates, try-throw-catch and Common Exceptions

Templates: meaning and why needed

A template allows us to write a function/class once and use it for different data types.

Why needed:

• avoids writing duplicate code for int, float, double, etc.
• supports generic programming
• improves reusability and maintainability

Example idea: max(a,b) should work for int, float, double.

Function templates: concept and basic syntax

A function template is a generic function definition.

Basic syntax:

• template <class T> or template <typename T>
• T func(T a, T b) { ... }

When called with a specific type, compiler creates the real function.

Template type parameter and template instantiation

• T is a type parameter (placeholder).
• When you call template with int, compiler instantiates a version for int.

Important point: template code is generated at compile time.

Overloading templates (intro)

Templates can be overloaded like normal functions. If a non-template function matches better, compiler may prefer it.

For Sem 1, keep idea simple: “Templates can be overloaded and compiler chooses best match.”

Class templates: concept and basic syntax

A class template is a generic class.

Example idea:

• template<class T> class Box { T data; ... }

When used as Box<int>, it becomes a class storing int.

Why templates are useful (generic programming)

Templates:

• reduce code duplication
• allow type-safe generic code (better than macros)
• help build reusable data structures (stack, queue, list)

Exception handling: meaning

An exception is an abnormal situation that occurs during program execution (e.g., divide by zero, file open failure).

Exception handling is a mechanism to handle such errors gracefully without crashing the program.

This improves reliability and separates normal logic from error-handling logic.

Keywords: try, throw, catch

• try: block where exception may occur.
• throw: used to signal an exception.
• catch: handles the thrown exception.

Flow:

• if exception occurs in try, control jumps to matching catch.

Multiple catch blocks and catch-all

We can write multiple catch blocks for different exception types.

Catch-all:

• catch(...) catches any type of exception.

Order matters:

• catch more specific exceptions first.

Stack unwinding (simple idea)

When an exception is thrown, C++ searches for a matching catch. If it moves out of functions, destructors for local objects are called automatically.

This process is called stack unwinding.

Common exceptions (practical examples)

Common situations:

• divide by zero
• invalid input
• array index out of range (logical handling)
• memory allocation failure (bad_alloc in advanced cases)

In Sem 1, focus on understanding try/throw/catch and writing a small flow.

Best practices in exception handling

• throw meaningful types/values (not random numbers)
• keep try blocks small
• catch specific exceptions before catch-all
• do not ignore exceptions silently
• use cleanup (or RAII concepts later)

Common mistakes

• writing catch(...) before specific catch blocks.
• throwing exceptions but not catching them.
• using exception handling as normal control flow (bad practice).

Mini tables/flowcharts for exam answers

Templates quick table

Exception handling flow

Normal code → try block
     ↓ exception occurs
throw exception → search matching catch → handle → continue/exit

Multiple catch order

catch(specific) → catch(less specific) → catch(...)

Quick Recap (1-minute revision)

• Templates help write generic code (function/class templates).
• Compiler instantiates template for specific types.
• Exception handling uses try-throw-catch.
• Multiple catch blocks: specific first, catch-all last.
• Stack unwinding calls destructors during exception propagation.