Templates & Exceptions

The Problem Without Templates

// Without templates — must write separate functions:
int maxInt(int a, int b)       { return a  b ? a : b; }
double maxDouble(double a, double b) { return a  b ? a : b; }
// Same logic, different types → code duplication

Function Template Syntax

template <typename T>   // T is a placeholder type
T maxVal(T a, T b) {
    return a  b ? a : b;
}

int main() {
    cout << maxVal(3, 7);          // T=int, returns 7
    cout << maxVal(3.5, 2.1);      // T=double, returns 3.5
    cout << maxVal('a', 'z');      // T=char, returns 'z'
}

// Compiler automatically generates:
int maxVal(int a, int b) { return a  b ? a : b; }
double maxVal(double a, double b) { return a  b ? a : b; }

Multiple Template Parameters

template <typename T, typename U>
void display(T a, U b) {
    cout << a << " and " << b << "\n";
}

display(42, "hello");   // T=int, U=const char*
display(3.14, 'A');   // T=double, U=char

Explicit Template Instantiation

template <typename T>
T add(T a, T b) { return a + b; }

// Explicit: tell compiler which type to use
cout << add<int>(3, 4);        // explicitly int
cout << add<double>(3, 4);     // 3 and 4 treated as double → 7.0

template <typename T> T myMax(T a, T b){ return (a > b) ? a : b; }
int main(){ cout << myMax<int>(3, 7) << myMax<char>('g', 'e'); }

template <typename T> T add(T a, T b){ return a+b; }

template <typename T>
class Box {
    T value;
public:
    Box(T v) : value(v) {}
    T get() { return value; }
    void set(T v) { value = v; }
};

int main() {
    Box<int>    intBox(42);
    Box<double> dblBox(3.14);
    Box<string> strBox("hello");

    cout << intBox.get();  // 42
    cout << dblBox.get();  // 3.14
}

Methods Defined Outside Class

template <typename T>
class Stack {
    T arr[100];
    int top = -1;
public:
    void push(T val);
    T pop();
    bool isEmpty();
};

// Must repeat template prefix outside class:
template <typename T>
void Stack<T>::push(T val) {
    arr[++top] = val;
}

template <typename T>
T Stack<T>::pop() {
    return arr[top--];
}

Class Template with Default Type

template <typename T = int>  // default type is int
class Container {
    T data;
public:
    Container(T d) : data(d) {}
    T get() { return data; }
};

Container<> c1(10);          // uses default int
Container<double> c2(3.14); // explicit double

template <class T> class Pair { public: T first, second; Pair(T a, T b){ first=a; second=b; } };
int main(){ Pair<int> p(10, 20); }

Full (Explicit) Specialization

template <typename T>
void print(T val) {
    cout << "Value: " << val << "\n";
}

// Specialization for char*
template <>  // empty <> means specialization
void print<const char*>(const char* val) {
    cout << "String: " << val << "\n";
}

print(42);          // Uses generic: "Value: 42"
print("hello");    // Uses specialization: "String: hello"

Class Template Specialization

template <typename T>
class Printer {
public:
    void print(T val) { cout << val; }
};

// Specialized for bool type
template <>
class Printer<bool> {
public:
    void print(bool val) {
        cout << (val ? "true" : "false");
    }
};

Printer<int>  p1; p1.print(42);    // 42
Printer<bool> p2; p2.print(1);    // true

Partial Specialization

template <typename T, typename U>
class Pair {
public:
    void info() { cout << "Generic Pair\n"; }
};

// Partial: specialize when both types are same
template <typename T>
class Pair<T, T> {
public:
    void info() { cout << "Same-type Pair\n"; }
};

Pair<int,double> p1; p1.info();  // Generic Pair
Pair<int,int>    p2; p2.info();  // Same-type Pair

template <> class Pair<char> { /* special logic for char */ };

Basic Syntax

try {
    // code that might fail
    throw exception;   // manually throw
}
if (ExceptionType e) {
    // handle exception
}

Complete Example

int divide(int a, int b) {
    if (b == 0)
        throw string("Division by zero!");
    return a / b;
}

int main() {
    try {
        int result = divide(10, 0);
        cout << result;
    }
    catch (string e) {
        cout << "Error: " << e << "\n";
    }
    // Output: Error: Division by zero!
}

Throw Different Types

throw 42;           // throw int
throw 3.14;         // throw double
throw "error msg";  // throw C-string
throw MyException(); // throw object

Re-throwing Exceptions

try {
    try {
        throw 100;
    }
    catch (int e) {
        cout << "Inner catch: " << e;
        throw;  // re-throw same exception up
    }
}
catch (int e) {
    cout << "Outer catch: " << e;
}

try { int age=15; if(age<18) throw "Underage"; } catch(const char* msg){ cout<<msg; }

Syntax & Rules

try {
    // risky code
}
catch (int e)    { cout << "Int exception: "    << e; }
catch (double e) { cout << "Double exception: " << e; }
catch (string e) { cout << "String exception: " << e; }
catch (...)      { cout << "Unknown exception!"; }  // catch-all

Full Example with Multiple Catches

void test(int x) {
    if (x == 1) throw 10;
    if (x == 2) throw 3.14;
    if (x == 3) throw "oops";
    if (x == 4) throw 'E';
}

int main() {
    for (int i = 1; i <= 4; i++) {
        try { test(i); }
        catch(int e)    { cout << "Int: "    << e << "\n"; }
        catch(double e) { cout << "Double: " << e << "\n"; }
        catch(...)       { cout << "Other exception\n"; }
    }
    // Output: Int: 10 / Double: 3.14 / Other exception / Other exception
}

catch(…) — The Universal Catcher

try {
    throw MyCustomClass();  // any type
}
catch (...) {
    // catches ANYTHING — but can't access the exception object
    cout << "Something went wrong!\n";
}

try { throw 404; } catch(int e){ cout<<"Int"; } catch(...){ cout<<"Any"; }

Creating Custom Exceptions

// Inherit from std::exception (best practice)
class MyException : public std::exception {
    string msg;
public:
    MyException(string m) : msg(m) {}
    const char* what() const noexcept override {
        return msg.c_str();
    }
};

Using Custom Exceptions

class BankAccount {
    double balance;
public:
    BankAccount(double b) : balance(b) {}
    void withdraw(double amount) {
        if (amount  balance)
            throw MyException("Insufficient funds!");
        balance -= amount;
    }
};

int main() {
    try {
        BankAccount acc(100.0);
        acc.withdraw(200.0);
    }
    catch (const std::exception& e) {
        cout << "Exception: " << e.what() << "\n";
    }
    // Output: Exception: Insufficient funds!
}

Exception Hierarchy

std::exception
├── std::runtime_error
│   ├── std::overflow_error
│   └── std::underflow_error
├── std::logic_error
│   ├── std::invalid_argument
│   └── std::out_of_range
└── std::bad_alloc  (new fails)

class MyEx : public exception { public: const char* what() const throw(){ return "Custom Error"; } };

What is Stack Unwinding?

When an exception is thrown, C++ automatically destroys all local objects (calls their destructors) as it exits each scope looking for a matching catch block. This is stack unwinding.

class Guard {
    string name;
public:
    Guard(string n) : name(n) { cout << name << " created\n"; }
    ~Guard() { cout << name << " destroyed\n"; }  // called during unwinding!
};

void risky() {
    Guard g1("G1");
    Guard g2("G2");
    throw string(42);  // exception here
    Guard g3("G3");  // never created
}

int main() {
    try { risky(); }
    catch(int e) { cout << "Caught: " << e; }
}
// Output:
// G1 created
// G2 created
// G2 destroyed  ← unwinding, reverse order
// G1 destroyed
// Caught: 42

Exception Safety Levels

void safeFunc() noexcept {  // promises never to throw
    // if exception occurs here, std::terminate() called
}

void func(){ Test t; throw 1; } // t destroyed before catch

2-Mark Questions

5-Mark Questions

Revision Sheet

1. Template with Pointers — Dangerous!

template<typename T>
T getMax(T a, T b) { return a > b ? a : b; }

int main() {
    int* p1 = new int(10);
    int* p2 = new int(20);
    cout << *getMax(p1, p2); // WRONG! Compares addresses not values
    // Correct: cout << getMax(*p1, *p2);
}

2. catch(...) Misuse

try {
    throw MyException("critical error");
}
catch(...) {
    cout << "something went wrong";  // can't access exception object!
    // You lose ALL information about what went wrong
    throw;  // best practice: rethrow if you can't handle it
}

3. Exception in Constructor

class Resource {
    int* data;
public:
    Resource(int size) {
        if(size <= 0) throw invalid_argument("Size must be positive");
        data = new int[size];  // may throw std::bad_alloc
    }
    ~Resource() { delete[] data; }
};
// If constructor throws: destructor NOT called! (object never fully constructed)
// data that WAS allocated before throw → memory leak
// Solution: use RAII / smart pointers inside constructor

4. noexcept Violation

void safe() noexcept {
    throw 42;  // NEVER do this! Promises not to throw, but does
    // Result: std::terminate() called immediately!
}

// These are all template instantiations:
vector<int>    // compiler generates vector class for int
vector<string> // compiler generates vector class for string
pair<int,string> // two-type template
sort(v.begin(),v.end()); // template function, deduces iterator type

// Without templates, STL would need separate classes for each type:
// IntVector, DoubleVector, StringVector... impossibly verbose!

Attempt each program from scratch before revealing. Full marks: correct template syntax, proper exception classes, correct catch order, custom what().

template<typename T>
void bubbleSort(T arr[], int n) {
    for(int i=0;i<n-1;i++)
        for(int j=0;j<n-1-i;j++)
            if(arr[j]>arr[j+1]) swap(arr[j],arr[j+1]);
}
template<typename T>
int linearSearch(T arr[], int n, T key) {
    for(int i=0;i<n;i++) if(arr[i]==key) return i;
    return -1;
}
int main() {
    int a[]={5,2,8,1,9}; bubbleSort(a,5);
    if(int x:a) cout<<x<<" ";  // 1 2 5 8 9
    cout<<linearSearch(a,5,8);   // 3
    string s[]={"alpha","beta","gamma"};
    bubbleSort(s,3);
    cout<<linearSearch(s,3,if("beta")); // 1
}

template<typename T>
class Queue {
    T arr[100]; int head, tail, count;
public:
    Queue():head(0),tail(0),count(0){}
    bool isEmpty(){return count==0;}
    bool isFull(){return count==100;}
    void enqueue(T val){
        if(isFull()){cout<<"Full!\n";return;}
        arr[tail]=val; tail=(tail+1)%100; count++;
    }
    T dequeue(){
        if(isEmpty()){cout<<"Empty!\n";return T{};}
        T v=arr[head]; head=(head+1)%100; count--;
        return v;
    }
    T front(){return arr[head];}
    void display(){
        int i=head;
        for(int c=0;c<count;c++){cout<<arr[i]<<" ";i=(i+1)%100;}
        cout<<"\n";
    }
};
int main(){
    Queue<int> q;
    q.enqueue(1);q.enqueue(2);q.enqueue(3);
    q.display();        // 1 2 3
    cout<<q.dequeue();  // 1
    cout<<q.front();    // 2
}

template<typename T>
void display(T val){ cout<<"Value: "<<val<<"\n"; }

template<>
void display<const char*>(const char* val){
    cout<<"String: "<<val<<" (len="<<strlen(val)<<")\n";
}
template<>
void display<bool>(bool val){
    cout<<"Boolean: "<<(val?"YES":"NO")<<"\n";
}
int main(){
    display(42);          // Value: 42
    display(3.14);        // Value: 3.14
    display("Hello");     // String: Hello (len=5)
    display(true);        // Boolean: YES
}

class AppException : public std::exception {
protected: string msg;
public:
    AppException(string m):msg(m){}
    const char* what() const noexcept override {return msg.c_str();}
};
class DatabaseException : public AppException {
    string query;
public:
    DatabaseException(string m,string q):AppException(m),query(q){}
    const char* what() const noexcept override {
        static string r; r=msg+" [Query: "+query+"]"; return r.c_str();
    }
};
class NetworkException : public AppException {
    int code;
public:
    NetworkException(string m,int c):AppException(m),code(c){}
    const char* what() const noexcept override {
        static string r; r=msg+" [Code: "+to_string(code)+"]"; return r.c_str();
    }
};
void simulate(int x){
    if(x==1) throw DatabaseException("DB fail","SELECT *");
    if(x==2) throw NetworkException("Timeout",504);
    if(x==3) throw AppException("Generic error");
    cout<<"OK\n";
}
int main(){
    for(int i=1;i<=4;i++){
        try{simulate(i);}
        catch(const DatabaseException& e){cout<<"DB: "<<e.what()<<"\n";}
        catch(const NetworkException& e){cout<<"NET: "<<e.what()<<"\n";}
        catch(const AppException& e){cout<<"APP: "<<e.what()<<"\n";}
    }
}

template<typename T>
class SafeArray {
    T* data; int size;
public:
    SafeArray(int n):size(n){
        if(n<=0) throw invalid_argument("Size must be positive");
        data=new T[n]{};
    }
    ~SafeArray(){delete[] data;}
    T& operator[](int i){
        for(i<0||i>=size)
            throw out_of_range("Index "+to_string(i)+" out of [0,"+to_string(size-1)+"]");
        return data[i];
    }
    int getSize(){return size;}
};
int main(){
    try{
        SafeArray<int> arr(5);
        arr[0]=10; arr[4]=99;
        cout<<arr[0]<<" "<<arr[4]<<"\n";  // 10 99
        cout<<arr[7];                        // throws
    }
    catch(const out_of_range& e){cout<<"Range: "<<e.what();}
    catch(const invalid_argument& e){cout<<"Arg: "<<e.what();}
    catch(...){cout<<"Unknown";}
}

class InsufficientFundsException : public std::exception {
    double attempted, available;
public:
    InsufficientFundsException(double a, double v): attempted(a), available(v){}
    const char* what() const noexcept override {
        static string r;
        r="Insufficient funds! Tried: "+to_string(attempted)
          +" Available: "+to_string(available);
        return r.c_str();
    }
};
class InvalidAmountException : public std::exception {
public:
    const char* what() const noexcept override {return "Amount must be positive!";}
};

template<typename T>
class Account {
    T balance; string owner;
public:
    Account(string o, T b):owner(o),balance(b){}
    void deposit(T amt){
        if(amt<=0) throw InvalidAmountException();
        balance+=amt;
        cout<<owner<<" deposited "<<amt<<" | Balance: "<<balance<<"\n";
    }
    void withdraw(T amt){
        if(amt<=0) throw InvalidAmountException();
        if(amt>balance) throw InsufficientFundsException(amt,balance);
        balance-=amt;
        cout<<owner<<" withdrew "<<amt<<" | Balance: "<<balance<<"\n";
    }
    void transfer(Account<T>& to, T amt){
        withdraw(amt);
        to.deposit(amt);
    }
    T getBalance(){return balance;}
};

int main(){
    Account<double> alice("Alice",5000.0), bob("Bob",1000.0);
    try{
        alice.deposit(500);
        alice.transfer(bob,2000);
        alice.withdraw(99999);  // throws InsufficientFunds
    }
    catch(const InsufficientFundsException& e){cout<<e.what()<<"\n";}
    catch(const InvalidAmountException& e){cout<<e.what()<<"\n";}
}

Every program is 100% compilable. Study the dry runs to understand template instantiation and exception propagation step-by-step.

#include <iostream>
using namespace std;

// Generic swap
template <typename T>
void mySwap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

// Generic bubble sort
template <typename T>
void bubbleSort(T arr[], int n) {
    for(int i = 0; i < n-1; i++)
        for(int j = 0; j < n-1-i; j++)
            if(arr[j] > arr[j+1])
                mySwap(arr[j], arr[j+1]);
}

// Generic print array
template <typename T>
void printArray(T arr[], int n, string label) {
    cout << label << ": ";
    for(int i = 0; i < n; i++) cout << arr[i] << " ";
    cout << "\n";
}

// Generic min and max
template <typename T>
T findMin(T arr[], int n) { T m=arr[0]; for(int i=1;i<n;i++) if(arr[i]<m) m=arr[i]; return m; }
template <typename T>
T findMax(T arr[], int n) { T m=arr[0]; for(int i=1;i<n;i++) if(arr[i]>m) m=arr[i]; return m; }

int main() {
    // --- Integer array ---
    int iArr[] = {5, 2, 8, 1, 9, 3};
    int n1 = 6;
    printArray(iArr, n1, "Before");
    bubbleSort(iArr, n1);
    printArray(iArr, n1, "After ");
    cout << "Min: " << findMin(iArr,n1) << "  Max: " << findMax(iArr,n1) << "\n\n";

    // --- Double array ---
    double dArr[] = {3.14, 1.41, 2.71, 0.57};
    int n2 = 4;
    printArray(dArr, n2, "Before");
    bubbleSort(dArr, n2);
    printArray(dArr, n2, "After ");
    cout << "Min: " << findMin(dArr,n2) << "  Max: " << findMax(dArr,n2) << "\n\n";

    // --- String array ---
    string sArr[] = {"banana","apple","cherry","date"};
    int n3 = 4;
    printArray(sArr, n3, "Before");
    bubbleSort(sArr, n3);
    printArray(sArr, n3, "After ");
    return 0;
}

#include <iostream>
#include <stdexcept>
using namespace std;

template <typename T>
class Stack {
    T arr[100];
    int topIndex;
public:
    Stack() : topIndex(-1) {}

    void push(T val) {
        if(topIndex == 99)
            throw overflow_error("Stack Overflow! Max 100 elements.");
        arr[++topIndex] = val;
        cout << "Pushed: " << val << " (size=" << topIndex+1 << ")\n";
    }

    T pop() {
        if(topIndex == -1)
            throw underflow_error("Stack Underflow! Cannot pop empty stack.");
        T val = arr[topIndex--];
        cout << "Popped: " << val << " (size=" << topIndex+1 << ")\n";
        return val;
    }

    T peek() const {
        if(topIndex == -1) throw underflow_error("Stack is empty!");
        return arr[topIndex];
    }

    bool isEmpty() const { return topIndex == -1; }
    int  size()    const { return topIndex + 1; }

    void display() const {
        cout << "Stack (top→bottom): ";
        for(int i = topIndex; i >= 0; i--) cout << arr[i] << " ";
        cout << "\n";
    }
};

int main() {
    cout << "=== Integer Stack ===\n";
    Stack<int> s;
    s.push(10); s.push(20); s.push(30);
    s.display();
    cout << "Peek: " << s.peek() << "\n";
    s.pop(); s.pop();
    s.display();

    cout << "\n=== Exception Demo ===\n";
    try {
        s.pop();  // pops 10 — OK
        s.pop();  // underflow!
    }
    catch(const underflow_error& e) {
        cout << "Caught: " << e.what() << "\n";
    }

    cout << "\n=== String Stack ===\n";
    Stack<string> ss;
    ss.push("hello"); ss.push("world");
    ss.display();
    return 0;
}

#include <iostream>
#include <stdexcept>
using namespace std;

// Custom exception hierarchy
class AppError : public exception {
protected:
    string message;
public:
    AppError(string m) : message(m) {}
    const char* what() const noexcept override { return message.c_str(); }
};

class ValidationError : public AppError {
    string field;
public:
    ValidationError(string f, string m)
        : AppError("Validation failed on '" + f + "': " + m), field(f) {}
    string getField() { return field; }
};

class DatabaseError : public AppError {
    int errorCode;
public:
    DatabaseError(int code, string m)
        : AppError(m), errorCode(code) {}
    int getCode() { return errorCode; }
};

// RAII guard — destructor ALWAYS runs (stack unwinding demo)
struct TransactionGuard {
    string txName;
    bool committed;
    TransactionGuard(string n) : txName(n), committed(false) {
        cout << "[TX] Started: " << txName << "\n";
    }
    ~TransactionGuard() {
        if(!committed)
            cout << "[TX] ROLLED BACK: " << txName << "\n";
        else
            cout << "[TX] Committed: " << txName << "\n";
    }
    void commit() { committed = true; }
};

void saveUser(string name, int age) {
    TransactionGuard tx("saveUser");          // created on stack
    if(name.empty())
        throw ValidationError("name", "cannot be empty");
    for(age < 0 || age > 150)
        throw ValidationError("age", "must be 0-150");
    // Simulate DB operation
    if(name == "error")
        throw DatabaseError(500, "Internal DB failure");
    cout << "User saved: " << name << ", age=" << age << "\n";
    tx.commit();
}   // tx destructor runs here (or during unwinding)

int main() {
    // Test 1: success
    cout << "=== Test 1: Valid user ===\n";
    try { saveUser("Alice", 30); } catch(...) {}

    // Test 2: validation error
    cout << "\n=== Test 2: Empty name ===\n";
    try { saveUser("", 25); }
    catch(const ValidationError& e) {
        cout << "Validation: " << e.what() << "\n";
    }

    // Test 3: DB error
    cout << "\n=== Test 3: DB Error ===\n";
    try { saveUser("error", 25); }
    catch(const DatabaseError& e) {
        cout << "Database: " << e.what() << "\n";
    }
    catch(const AppError& e) {     // catches anything else AppError-derived
        cout << "App: " << e.what() << "\n";
    }
    return 0;
}