Exception Class Hierarchy

In C++, you can create your own custom exception classes by deriving them from the standard exception class hierarchy. The std::exception class serves as the base class for all standard exceptions, and you can inherit from it to create your own specialized exception classes.

Here's an example of creating a custom exception class:

1#include <iostream>
2#include <exception>
3#include <string>
4
5class MyException : public std::exception {
6public:
7  explicit MyException(const std::string& message)
8    : message_(message) {}
9
10  const char* what() const noexcept override {
11    return message_.c_str();
12  }
13
14private:
15  std::string message_;
16};

In this example, we define a custom exception class called MyException that inherits from std::exception. The class has a constructor that takes an error message as a parameter and stores it in a private member variable.

We override the what() member function, which is a virtual function defined in the std::exception class. This function returns a C-style string (const char*) that represents the error message associated with the exception. We return the stored error message using the c_str() function of std::string.

To use the custom exception class, you can throw an instance of it using the throw keyword:

1try {
2  // Some code that may throw an exception
3  throw MyException("Something went wrong!");
4} catch (const MyException& ex) {
5  std::cout << "Caught MyException: "
6    << ex.what();
7} catch (const std::exception& ex) {
8  std::cout << "Caught std::exception: "
9    << ex.what();
10}

In this example, we throw an instance of MyException with a specific error message. The exception can be caught using a catch block that specifically handles MyException, or it can be caught by a more general catch block that handles std::exception, since MyException inherits from it.

By creating custom exception classes, you can provide more specific and meaningful error information in your code, making it easier to handle and diagnose exceptions.