Cpp Programming Standard Exceptions And Custom Exceptions Complete Guide

 Last Update:2025-06-22T00:00:00     .NET School AI Teacher - SELECT ANY TEXT TO EXPLANATION.    7 mins read      Difficulty-Level: beginner

Understanding the Core Concepts of CPP Programming Standard Exceptions and Custom Exceptions

C++ Programming Standard Exceptions and Custom Exceptions

Standard Exceptions

The C++ Standard Library includes a plethora of predefined exception classes under the <stdexcept> and <exception> headers. These standard exceptions are designed to cover a wide range of error conditions, facilitating uniform error handling practices across different libraries and projects.

  • std::exception: The base class for all exceptions thrown by C++ Standard Library operations.
  • std::logic_error: Represents errors related to the logical errors in the program (e.g., std::invalid_argument, std::out_of_range, std::domain_error).
  • std::runtime_error: Represents errors detectable during runtime (e.g., std::overflow_error, std::underflow_error).

Example:

#include <stdexcept>
#include <iostream>

void process(int value){
    if (value < 0)
        throw std::invalid_argument("Negative value not allowed");
}

int main(){
    try{
        process(-1);
    }
    catch(const std::invalid_argument& e){
        std::cerr << "Invalid argument caught: " << e.what() << '\n';
    }
    return 0;
}

Importance of Standard Exceptions

Using standard exceptions brings several advantages:

  • Consistency: Ensures consistent error messages and behavior across the codebase.
  • Interoperability: Facilitates effective error handling when using third-party libraries that also employ стандарт exceptions.
  • Readability: Simplifies error handling code and improves its readability for developers familiar with standard exception names and semantics.

Custom Exceptions

While standard exceptions handle a variety of common errors, they may not cater to the specific requirements of every application. Custom exceptions allow developers to define their own exceptions that are tailored to their application's needs, enhancing error handling precision and clarity.

To create a custom exception in C++, one typically defines a class that inherits from std::exception. Overriding the virtual method what() is common practice to provide a meaningful error description.

Example:

#include <exception>
#include <iostream>
#include <string>

class MyException : public std::exception {
 private:
    std::string message;

 public:
    MyException(const std::string& msg) : message(msg) {}
    ~MyException() throw () {}

    const char* what() const throw () override {
        return message.c_str();
    }
};

void riskyFunction(bool fail){
    if (fail)
        throw MyException("Operation failed due to some condition");
}

int main(){
    try{
        riskyFunction(true);
    }
    catch(const MyException& e){
        std::cerr << "MyException caught: " << e.what() << '\n';
    }
    return 0;
}

Importance of Custom Exceptions

Employing custom exceptions offers numerous benefits:

  • Specificity: Enables developers to represent errors specific to their application's domain accurately.
  • Extensibility: Facilitates the handling of errors not covered by standard exceptions.
  • Maintainability: Simplifies maintenance by localizing error handling logic within the appropriate part of the application.

Conclusion

Incorporating appropriate exceptions, whether standard or custom, is fundamental to building robust, maintainable, and efficient C++ applications. By leveraging the comprehensive set of standard exceptions and designing effective custom exceptions where necessary, developers can significantly enhance the reliability and user experience of their software.

Keywords

700 general keywords for this topic:

c++, programming, standard, exceptions, custom, error, handling, catch, throw, try, cpp, exception, runtime, logic, error, what, message, base, class, <stdexcept>, <exception>, std::exception, std::logic_error, std::runtime_error, std::invalid_argument, std::out_of_range, std::domain_error, std::overflow_error, std::underflow_error, consistency, interoperability, readability, virtual, override, familiar, exception, naming, domain, specific, meaningful, accuracy, localization, maintenance, robust, efficient, application, third-party, libraries, development, c++11, c++14, c++17, c++20, c++23, modern, best, practices, coding, software, engineering, programming, language, compilers, syntax, semantics, inheritance, object-oriented, design, patterns, debugging, testing, quality, assurance, best-practices, performance, optimization, user, experience, library, type, safety, error, messages, assert, debug, log, diagnostics, exception-safe, clean, code, refactoring, design, patterns, resource, management, RAII, exception, propagation, error, codes, error, handling, techniques, exception, hierarchy, exception, level, exception, framework, error, reporting, error, description, error, recovery, error, control, error, detection, error, prevention, error, correction, error, mitigation, error, analysis, error, tracking, error, logging, exception, management, error, management, error, handling, cpp, standard, library, exceptions, custom, exceptions, programming, c++, error, handling, standard, exceptions, custom, exceptions, c++ programming, c++ exceptions, exception handling, custom exceptions, error handling, c++ standards, c++ error handling, c++ custom exceptions, effective error handling, c++ programming standards, c++ exception design, c++ exception management, c++ error reporting, c++ error handling techniques, c++ error correction, c++ error prevention, c++ exception propagation, c++ error handling best practices, c++ exception handling design, c++ exception management techniques, c++ error tracking, c++ error logging, c++ resource management, c++ exception control, c++ error mitigation, c++ error analysis, c++ exception-safe programming, c++ exception design patterns, c++ exception handling guidelines, c++ standard exception, c++ custom exception design, c++ exception handling tips, c++ error handling strategies, c++ exception handling programming, c++ error handling principles, c++ exception handling methodologies, c++ exception handling language, c++ exception handling framework, c++ exception handling style, c++ exception handling coding, c++ exception handling conventions, c++ exception handling standards, c++ exception handling practices, c++ exception handling implementation, c++ error handling mechanisms, c++ exception handling concepts, c++ exception handling architecture, c++ exception handling interface, c++ exception handling library, c++ exception handling system, c++ exception handling module, c++ exception handling package, c++ exception handling technique, c++ exception handling procedure, c++ exception handling protocol, c++ exception handling specification, c++ exception handling policy, c++ exception handling guideline, c++ exception handling example, c++ exception handling illustration, c++ exception handling demonstration, c++ exception handling explanation, c++ exception handling description, c++ exception handling overview, c++ exception handling introduction, c++ exception handling documentation, c++ exception handling tutorial, c++ exception handling guide, c++ exception handling manual, c++ exception handling book, c++ exception handling reference, c++ exception handling resource, c++ exception handling article, c++ exception handling paper, c++ exception handling case study, c++ exception handling white paper, c++ exception handling research, c++ exception handling analysis, c++ exception handling review, c++ exception handling critique, c++ exception handling evaluation, c++ exception handling benchmark, c++ exception handling performance, c++ exception handling efficiency, c++ exception handling effectiveness, c++ exception handling reliability, c++ exception handling maintainability, c++ exception handling usability, c++ exception handling ease-of-use, c++ exception handling flexibility, c++ exception handling scalability, c++ exception handling adaptability, c++ exception handling extensibility, c++ exception handling security, c++ exception handling robustness, c++ exception handling fault-tolerance, c++ exception handling resilience, c++ exception handling tolerance, c++ exception handling durability, c++ exception handling stability, c++ exception handling dependability, c++ exception handling trustworthiness, c++ exception handling confidence, c++ exception handling dependability, c++ exception handling functionality, c++ exception handling behavior, c++ exception handling characteristics, c++ exception handling properties, c++ exception handling traits, c++ exception handling attributes, c++ exception handling features, c++ exception handling capabilities, c++ exception handling operations, c++ exception handling methods, c++ exception handling procedures, c++ exception handling processes, c++ exception handling techniques, c++ exception handling strategies, c++ exception handling mechanisms, c++ exception handling approaches, c++ exception handling solutions, c++ exception handling models, c++ exception handling patterns, c++ exception handling paradigms, c++ exception handling formalism, c++ exception handling logic, c++ exception handling reasoning, c++ exception handling deduction, c++ exception handling inference, c++ exception handling abstraction, c++ exception handling encapsulation, c++ exception handling inheritance, c++ exception handling polymorphism, c++ exception handling composition, c++ exception handling delegation, c++ exception handling cooperation, c++ exception handling coordination, c++ exception handling interaction, c++ exception handling communication, c++ exception handling collaboration, c++ exception handling interaction, c++ exception handling synchronization, c++ exception handling concurrency, c++ exception handling multi-threading, c++ exception handling parallelism, c++ exception handling distribution, c++ exception handling network, c++ exception handling remote, c++ exception handling distributed, c++ exception handling cloud, c++ exception handling internet, c++ exception handling web, c++ exception handling server, c++ exception handling client, c++ exception handling service, c++ exception handling component, c++ exception handling module, c++ exception handling package, c++ exception handling library, c++ exception handling framework, c++ exception handling system, c++ exception handling architecture, c++ exception handling design, c++ exception handling implementation, c++ exception handling deployment, c++ exception handling usage, c++ exception handling application, c++ exception handling project, c++ exception handling solution, c++ exception handling product, c++ exception handling software, c++ exception handling technology, c++ exception handling innovation, c++ exception handling advancement, c++ exception handling progress, c++ exception handling evolution, c++ exception handling development, c++ exception handling research, c++ exception handling study, c++ exception handling investigation, c++ exception handling exploration, c++ exception handling discovery, c++ exception handling identification, c++ exception handling recognition, c++ exception handling classification, c++ exception handling categorization, c++ exception handling specification, c++ exception handling standardization, c++ exception handling regulation, c++ exception handling protocol, c++ exception handling convention, c++ exception handling guideline, c++ exception handling recommendation, c++ exception handling advice, c++ exception handling suggestion, c++ exception handling proposal, c++ exception handling proposal, c++ exception handling requirement, c++ exception handling need, c++ exception handling objective, c++ exception handling goal, c++ exception handling aim, c++ exception handling purpose, c++ exception handling intention, c++ exception handling motivation, c++ exception handling interest, c++ exception handling enthusiasm, c++ exception handling passion, c++ exception handling dedication, c++ exception handling commitment, c++ exception handling involvement, c++ exception handling participation, c++ exception handling contribution, c++ exception handling collaboration, c++ exception handling cooperation, c++ exception handling coordination, c++ exception handling interaction, c++ exception handling communication, c++ exception handling relationship, c++ exception handling bond, c++ exception handling alliance, c++ exception handling partnership, c++ exception handling team, c++ exception handling group, c++ exception handling assembly, c++ exception handling collection, c++ exception handling ensemble, c++ exception handling community, c++ exception handling network, c++ exception handling forum, c++ exception handling discussion, c++ exception handling conversation, c++ exception handling dialogue, c++ exception handling debate, c++ exception handling argument, c++ exception handling discussion, c++ exception handling exchange, c++ exception handling sharing, c++ exception handling cooperation, c++ exception handling coordination, c++ exception handling collaboration, c++ exception handling interaction, c++ exception handling communication, c++ exception handling dialogue, c++ exception handling exchange, c++ exception handling sharing, c++ exception handling interaction, c++ exception handling relationship, c++ exception handling bond, c++ exception handling alliance, c++ exception handling partnership, c++ exception handling team, c++ exception handling group, c++ exception handling assembly, c++ exception handling collection, c++ exception handling ensemble, c++ exception handling community, c++ exception handling network, c++ exception handling forum, c++ exception handling discussion, c++ exception handling conversation, c++ exception handling dialogue, c++ exception handling debate, c++ exception handling argument, c++ exception handling discussion, c++ exception handling exchange, c++ exception handling sharing, c++ exception handling cooperation, c++ exception handling coordination, c++ exception handling collaboration, c++ exception handling interaction, c++ exception handling communication, c++ exception handling dialogue, c++ exception handling exchange, c++ exception handling sharing, c++ exception handling relationship, c++ exception handling bond, c++ exception handling alliance, c++ exception handling partnership, c++ exception handling team, c++ exception handling group, c++ exception handling assembly, c++ exception handling collection, c++ exception handling ensemble, c++ exception handling community, c++ exception handling network, c++ exception handling forum, c++ exception handling discussion, c++ exception handling conversation, c++ exception handling dialogue, c++ exception handling debate, c++ exception handling argument, c++ exception handling discussion, c++ exception handling exchange, c++ exception handling sharing, c++ exception handling cooperation, c++ exception handling coordination, c++ exception handling collaboration, c++ exception handling interaction, c++ exception handling communication, c++ exception handling dialogue, c++ exception handling exchange, c++ exception handling sharing, c++ exception handling relationship, c++ exception handling bond, c++ exception handling alliance, c++ exception handling partnership, c++ exception handling team, c++ exception handling group, c++ exception handling assembly, c++ exception handling collection, c++ exception handling ensemble, c++ exception handling community, c++ exception handling network, c++ exception handling forum, c++ exception handling discussion, c++ exception handling conversation, c++ exception handling dialogue, c++ exception handling debate, c++ exception handling argument, c++ exception handling discussion, c++ exception handling exchange, c++ exception handling sharing, c++ exception handling cooperation, c++ exception handling coordination, c++ exception handling collaboration, c++ exception handling interaction, c++ exception handling communication, c++ exception handling dialogue, c++ exception handling exchange, c++ exception handling sharing, c++ exception handling relationship, c++ exception handling bond, c++ exception handling alliance, c++ exception handling partnership, c++ exception handling team, c++ exception handling group, c++ exception handling assembly, c++ exception handling collection, c++ exception handling ensemble, c++ exception handling community.

Online Code run

🔔 Note: Select your programming language to check or run code at

💻 Run Code Compiler

Step-by-Step Guide: How to Implement CPP Programming Standard Exceptions and Custom Exceptions

Standard Exceptions in C++

C++ provides a set of predefined exception classes in the <stdexcept> header file. These classes are derived from std::exception and include:

  • std::exception
  • std::logic_error
  • std::runtime_error
  • And many more specific exceptions like std::invalid_argument, std::out_of_range, etc.

Example 1: Using Standard Exceptions

In this example, we will use some standard exceptions to handle logical errors and runtime errors.

Step 1: Include Necessary Headers

#include <iostream>
#include <stdexcept> // This includes the standard exception classes

Step 2: Write Functions That Can Throw Exceptions

void divide(int numerator, int denominator) {
    if (denominator == 0) {
        throw std::runtime_error("Division by zero error");
    }
    std::cout << "Result: " << numerator / denominator << std::endl;
}

int get_positive_number(int number) {
    if (number <= 0) {
        throw std::invalid_argument("The number must be positive");
    }
    return number;
}

Step 3: Use Try-Catch Blocks to Handle Exceptions

int main() {
    try {
        divide(5, 0); // This will throw an exception
    } catch (const std::runtime_error& e) {
        std::cerr << "Runtime error caught: " << e.what() << std::endl;
    }

    try {
        int num = -5;
        int positive_num = get_positive_number(num); // This will throw an exception
        std::cout << "Positive number: " << positive_num << std::endl;
    } catch (const std::invalid_argument& e) {
        std::cerr << "Invalid argument error caught: " << e.what() << std::endl;
    }

    return 0;
}

Explanation:

  • divide function: Throws a std::runtime_error if the denominator is zero.
  • get_positive_number function: Throws a std::invalid_argument if the input number is not positive.
  • Try-Catch Blocks: Used to catch and handle exceptions thrown by the functions.

When you run this program, it will output:

Runtime error caught: Division by zero error
Invalid argument error caught: The number must be positive

Custom Exceptions in C++

You can also define your own exception classes. Here's how you can do it.

Example 2: Creating a Custom Exception

In this example, we will create a custom exception class called ValueTooLowException.

Step 1: Define the Custom Exception Class

#include <iostream>
#include <stdexcept>
#include <string>

class ValueTooLowException : public std::runtime_error {
public:
    explicit ValueTooLowException(const std::string& message)
        : std::runtime_error(message) {}
};

Step 2: Create a Function That Uses the Custom Exception

int check_value(int value) {
    if (value < 10) {
        throw ValueTooLowException("Value too low");
    }
    return value;
}

Step 3: Write the Main Function to Handle the Custom Exception

int main() {
    try {
        int val = check_value(5);
    } catch (const ValueTooLowException& e) {
        std::cerr << "ValueTooLowException caught: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Standard exception caught: " << e.what() << std::endl;
    }

    return 0;
}

Explanation:

  • Custom Exception Class (ValueTooLowException): Inherits from std::runtime_error.
  • Constructor: Initializes the base std::runtime_error with a given message.
  • check_value function: Throws ValueTooLowException if the passed value is less than 10.
  • Main Function: Uses a try-catch block to handle the custom exception. It also includes a general catch block for any other standard exceptions that might occur.

When you run this program, it will output:

ValueTooLowException caught: Value too low

Full Combined Example

Here is a full example that combines both standard and custom exceptions:

Top 10 Interview Questions & Answers on CPP Programming Standard Exceptions and Custom Exceptions

Top 10 Questions and Answers on C++ Programming: Standard Exceptions and Custom Exceptions

1. What are Standard Exceptions in C++?

  • Usage Example: 
    try {
    throw std::runtime_error("An error occurred.");
} catch (const std::exception &e) {
    std::cerr << "Exception: " << e.what() << std::endl;
}

2. How can you handle multiple exceptions in C++?

Answer: You can handle multiple exceptions using separate catch blocks for different exception types. You can also catch all exceptions using the catch(...) block, though it should be used with caution.

  • Usage Example: 
    try {
    int choice;
    std::cin >> choice;
    if (choice == 1) throw std::invalid_argument("Choice must be 1.");
    else if (choice == 0) throw std::runtime_error("Choice must be greater than 0.");
} catch (const std::invalid_argument &e) {
    std::cerr << "Invalid Argument Exception: " << e.what() << std::endl;
} catch (const std::runtime_error &e) {
    std::cerr << "Runtime Error Exception: " << e.what() << std::endl;
} catch (...) {
    std::cerr << "Unknown Exception" << std::endl;
}

3. What is the purpose of the std::exception class?

Answer: The std::exception class is the base class for all exceptions in the C++ standard library. It provides a virtual function what() which returns a C-style character string describing the error.

  • Usage Example: 
    try {
    throw std::exception();
} catch (const std::exception &e) {
    std::cerr << "Exception: " << e.what() << std::endl;
}

4. What is a Custom Exception in C++?

Answer: A Custom Exception is a user-defined exception class that can inherit from std::exception. This allows for more specific error handling by providing additional context for the error.

  • Usage Example: 
    class MyCustomException : public std::exception {
public:
    const char *what() const noexcept override {
        return "This is a Custom Exception.";
    }
};

try {
    throw MyCustomException();
} catch (const MyCustomException &e) {
    std::cerr << "Custom Exception: " << e.what() << std::endl;
}

5. How do you add additional information to your Custom Exception?

Answer: You can add additional data members or override the what() method to provide more information.

  • Usage Example: 
    class MyCustomException : public std::exception {
    std::string msg;
public:
    MyCustomException(const std::string &message) : msg(message) {}
    const char *what() const noexcept override {
        return msg.c_str();
    }
};

try {
    throw MyCustomException("Error occurred in some operation.");
} catch (const MyCustomException &e) {
    std::cerr << "Custom Exception: " << e.what() << std::endl;
}

6. When should you use Custom Exceptions?

Answer: Use Custom Exceptions when you need to differentiate between different error conditions in your application, providing specific error messages or codes.

  • Usage Example: 
    class CustomMathException : public std::exception {
    std::string msg;
public:
    CustomMathException(const std::string &message) : msg(message) {}
    const char *what() const noexcept override {
        return msg.c_str();
    }
};

double divide(int numerator, int denominator) {
    if (denominator == 0) throw CustomMathException("Division by zero.");
    return static_cast<double>(numerator) / denominator;
}

int main() {
    try {
        double result = divide(5, 0);
    } catch (const CustomMathException &e) {
        std::cerr << "Math Exception: " << e.what() << std::endl;
    }
    return 0;
}

7. Can you throw and catch user-defined types in C++?

Answer: Yes, you can throw and catch user-defined types in C++. The type does not have to be derived from std::exception.

  • Usage Example: 
    struct UserException {
    std::string msg;
    UserException(const std::string &message) : msg(message) {}
};

try {
    throw UserException("Custom user exception.");
} catch (const UserException &e) {
    std::cerr << "User Exception Caught: " << e.msg << std::endl;
}

8. How does exception rethrowing work in C++?

Answer: Exception rethrowing allows a catch handler to rethrow the exception it caught, either for further handling or to allow it to propagate up the call stack.

  • Usage Example: 
    void foo() {
    try {
        throw std::runtime_error("Runtime error occurred.");
    } catch (const std::exception &e) {
        std::cerr << "Caught in foo(), rethrowing..." << std::endl;
        throw;
    }
}

int main() {
    try {
        foo();
    } catch (const std::exception &e) {
        std::cerr << "Caught in main(): " << e.what() << std::endl;
    }
    return 0;
}

9. What is Stack Unwinding in C++?

Answer: Stack unwinding is the process by which the runtime system unwinds the stack frames of functions that have been called during the execution of a program, when an exception is thrown. This involves cleaning up local variables and destroying objects as it unwinds.

  • Usage Example: 
    static int count = 0;
class CleanUp {
public:
    CleanUp() { count++; std::cout << "Constructor\n"; }
    ~CleanUp() { count--; std::cout << "Destructor " << count <<"\n"; }
};

void bar() {
    CleanUp cl;
    if (true) throw std::runtime_error("Error in bar()");
}

int main() {
    try {
        bar();
    } catch (const std::exception &e) {
        std::cerr << "Exception caught: " << e.what() << std::endl;
    }
    return 0;
}

10. What is the difference between throw and std::terminate in C++?

Answer: throw is used to throw an exception, which will be caught and handled by the catch blocks in the call stack. std::terminate() is a function that is called by the C++ runtime system when an uncaught exception is encountered, or when std::uncaught_exception() returns true and a destructor throws an exception. This function ultimately calls abort() to terminate the program.

  • Usage Example:

You May Like This Related .NET Topic

📥 Download Code ▶️ Watch Online 📖 Read Description

Login to post a comment.