Exception handling

 

Exception handling is a crucial concept in programming, and it can be effectively explained through the analogy of a stack operation. In exception handling, a program maintains a stack of operations, much like a stack of plates. Each time a function or method is called, a new plate (or frame) is added to the stack. When an exception is thrown, the program looks for the nearest exception handler that can catch and handle the exception.

Here's how the stack operation analogy relates to exception handling:

1. Pushing onto the Stack: When a function or method is called, a new stack frame is pushed onto the stack. This frame contains information about the function's local variables and execution context. It's like adding a new plate to the top of the stack.

2. Popping from the Stack: When a function completes its execution, its stack frame is popped off the stack. This is similar to removing a plate from the top of the stack.

3. Exception Thrown: If an exception is thrown, the program starts looking for an exception handler by examining the stack frames in reverse order. It checks each frame to see if there's an appropriate exception handler for the thrown exception. This process continues until an appropriate handler is found or until the stack is empty.

4. Exception Handling: If an exception handler is found, it's like catching the thrown exception with the matching plate on top of the stack. The program then executes the code in the handler to deal with the exception. If no handler is found, the program terminates, and an error message is displayed.

In essence, the stack of function calls mirrors the flow of program execution, and exception handling allows you to gracefully deal with unexpected issues during this execution. By effectively using exception handling, you can ensure that your program doesn't crash but can recover from errors, much like catching and handling plates from a stack without causing a messy pile-up.

 

#include <iostream>
#include <stdexcept>
using namespace std;
const int MAX_SIZE = 5; // Maximum size of the stack

class Stack{
private:
    int items[MAX_SIZE];
    int top;

public:
    Stack() : top(-1) {}

    void push(int value) {
        if (top >= MAX_SIZE - 1) {
            throw overflow_error("Stack overflow");
        }
        items[++top] = value;
    }

    int pop() {
        if (top < 0) {
            throw underflow_error("Stack Underflow");
        }
        return items[top--];
    }
};
int main() {
    Stack stack;

    try {
        for (int i = 1; i <= MAX_SIZE + 1; i++) {
            stack.push(i); // Try to push more elements than the stack can hold
            cout << "Pushed: "<<i<<endl;
        }
    } catch (const exception& e){
        cerr << "Exception: " << e.what() << endl;
    }
    try {
        for (int i = 1; i <= MAX_SIZE + 1; i++) {
            int value = stack.pop(); // Try to pop more elements than available
            cout << "Popped: " << value << endl;
        }
    } catch (const exception& e) {
        cerr << "Exception: " << e.what() << endl;
    }

    return 0;
}