stdexcept

---

1. Exception Handling in Array Indexing

int main() {
  // Create an array of size 5
  int arr[] = {1, 2, 3, 4, 5};

  try {
    // Attempt to access an index out of bounds
    int value = arr[5];
    std::cout << "Value at index 5: " << value << std::endl;
  } catch (std::out_of_range& e) {
    std::cout << "Exception: " << e.what() << std::endl;
  }

  return 0;
}

2. Exception Handling in File Operations

int main() {
  try {
    // Open a file that does not exist
    std::ifstream file("non_existing_file.txt");
  } catch (std::ifstream::failure& e) {
    std::cout << "Exception: " << e.what() << std::endl;
  }

  return 0;
}

3. Exception Handling in Pointer Dereferencing

int main() {
  int* ptr = nullptr;

  try {
    // Attempt to dereference a null pointer
    int value = *ptr;
  } catch (std::runtime_error& e) {
    std::cout << "Exception: " << e.what() << std::endl;
  }

  return 0;
}

4. Exception Handling in Function Calls

int divide(int a, int b) {
  if (b == 0) {
    throw std::invalid_argument("Division by zero");
  }

  return a / b;
}

int main() {
  try {
    int result = divide(10, 0);
    std::cout << "Result: " << result << std::endl;
  } catch (std::invalid_argument& e) {
    std::cout << "Exception: " << e.what() << std::endl;
  }

  return 0;
}

5. Exception Handling in Class Constructors

class MyClass {
public:
  MyClass() {
    // Initialize member variables
    if (condition) {
      throw std::runtime_error("Initialization error");
    }
  }
};

int main() {
  try {
    MyClass object;
  } catch (std::runtime_error& e) {
    std::cout << "Exception: " << e.what() << std::endl;
  }

  return 0;
}

6. Exception Handling in Destructors

class MyClass {
public:
  ~MyClass() {
    // Release resources
    if (condition) {
      throw std::runtime_error("Destruction error");
    }
  }
};

int main() {
  try {
    // Create an object and let it go out of scope
    {
      MyClass object;
    }
  } catch (std::runtime_error& e) {
    std::cout << "Exception: " << e.what() << std::endl;
  }

  return 0;
}

7. Exception Handling in operator overloading

class MyClass {
public:
  MyClass& operator=(const MyClass& other) {
    if (condition) {
      throw std::runtime_error("Assignment error");
    }

    // Assignment implementation

    return *this;
  }
};

8. Exception Handling in Copy Constructors

class MyClass {
public:
  MyClass(const MyClass& other) {
    if (condition) {
      throw std::runtime_error("Copy constructor error");
    }

    // Copy constructor implementation
  }
};

9. Exception Handling in Default Constructors

class MyClass {
public:
  MyClass() {
    if (condition) {
      throw std::runtime_error("Default constructor error");
    }

    // Default constructor implementation
  }
};

10. Exception Handling in Move Constructors

class MyClass {
public:
  MyClass(MyClass&& other) {
    if (condition) {
      throw std::runtime_error("Move constructor error");
    }

    // Move constructor implementation
  }
};

11. Exception Handling in Iterators

class MyIterator {
public:
  MyIterator() {
    if (condition) {
      throw std::runtime_error("Iterator error");
    }

    // Iterator initialization
  }
};

12. Exception Handling in Function Templates

template <typename T>
T divide(T a, T b) {
  if (b == 0) {
    throw std::invalid_argument("Division by zero");
  }

  return a / b;
}

13. Exception Handling in Class Templates

template <typename T>
class MyClass {
public:
  MyClass() {
    if (T() == T()) {
      throw std::runtime_error("Class template error");
    }
  }
};

14. Exception Handling in operator Overloading Templates

template <typename T>
T operator+(const T& a, const T& b) {
  if (condition) {
    throw std::runtime_error("Operator overloading error");
  }

  return a + b;
}

15. Exception Handling in Test Fixtures

#include <gtest/gtest.h>

class MyClassTest : public ::testing::Test {
protected:
  void SetUp() override {
    if (condition) {
      throw std::runtime_error("Test fixture error");
    }
  }
};

16. Exception Handling in Assertion Macros

#include <gtest/gtest.h>

TEST(MyClassTest, MyFunction) {
  ASSERT_NO_THROW(myFunction());
}

17. Exception Handling in Catch Blocks

try {
  // Code that may throw an exception
} catch (std::exception& e) {
  std::cout << "Exception caught: " << e.what() << std::endl;
} catch(...) {
  std::cout << "Unknown exception caught" << std::endl;
}

18. Exception Handling in Nested Catch Blocks

try {
  // Code that may throw an exception
} catch (std::invalid_argument& e) {
  // Handle invalid argument exception
} catch (std::runtime_error& e) {
  // Handle runtime error exception