Exception handling in C++ is a particular condition for developers to handle. In programming, committing mistakes that prompt unusual conditions called errors is normal. All in all, these errors are of three kinds:<\/p>\n\n\n\n
\n C++ Programming Course<\/a>\n <\/p>\n Master key C++ programming concepts like variables, functions, OOP, and control structures. Build real-world projects such as a banking system and grade management tool.<\/p>\n Exception handling in C++ is a mechanism that allows a program to deal with runtime errors and exceptional situations in a structured and controlled manner. In C++, exceptions are used to handle errors that occur during the execution of a program, such as division by zero, accessing invalid memory, or file I\/O errors.<\/p>\n\n\n\n The basic idea behind exception handling is to separate the normal flow of program execution from error-handling code. Instead of terminating the program abruptly when an error occurs, C++ provides a way to \"throw\" an exception, representing the error or exceptional condition. The thrown exception is then caught by appropriate \"catch\" blocks, where the program can handle the error gracefully.<\/p>\n\n\n\n Here's a basic outline of how exception handling works in C++:<\/p>\n\n\n\n By using exception handling, you can make your C++ programs more robust and maintainable, as they provide a way to handle errors in a controlled manner, rather than having the program terminate abruptly on encountering an issue.<\/p>\n\n\n\n When no exception condition happens, the code will execute ordinarily. The handlers will be disregarded.<\/p>\n\n\n\n A simple example to understand Exceptional handling in C++<\/strong><\/p>\n\n\n\n In this example, the division operation numerator\/denominator may throw a std::exception when the denominator is zero. The try block contains the code that might throw an exception, and the catch block catches the exception and handles it appropriately.<\/p>\n\n\n\n Also, now you can learn Exception Handling in C - A Free Online Course in Hindi<\/a><\/em><\/strong><\/p>\n\n\n\n Exception handling is a crucial concept in programming that allows developers to deal with unexpected or exceptional situations that may occur during the execution of a program. These exceptional situations are often referred to as \"exceptions.\" Here are some reasons why exception handling is important:<\/p>\n\n\n\n Exception Handling in C++ falls around these three keywords: <\/p>\n\n\n\n In C++, Here's a brief explanation of each keyword:<\/p>\n\n\n\n <\/p>\n\n\n\n In C++, exception handling is done using the Here's an example to illustrate the usage of Example1: Multiple Code Block <\/strong><\/p>\n\n\n\n Here, we have added an additional Example2: Throwing a Custom Exception<\/strong><\/p>\n\n\n\n In this example, the Try-catch is an important keyword while performing exceptional conditions. To catch exceptions<\/strong>, a part of the code is kept under <\/strong>inspection. This is done by closing that part of the code in a try-block. When an exceptional circumstance arises within that block, an exception<\/strong> is thrown and an exception handler takes control over the program. <\/p>\n\n\n\n In C++, you can throw an exception using the throw keyword. Exceptions are a way to handle error conditions or exceptional situations in your code that may disrupt the normal flow of execution. When an exception is thrown, the program will stop executing the current block of code and start searching for an appropriate exception handler (catch block) to handle the exception.<\/p>\n\n\n\n To throw an exception in C++, you typically follow these steps:<\/p>\n\n\n\n Define a custom exception class (optional): Throw the exception: Catch the exception (optional): Here's an example of how to throw and catch an exception in C++:<\/p>\n\n\n\n In C++, you can create your own user-defined exceptions to handle specific error conditions in your code. User-defined exceptions allow you to define custom exception types that inherit from the standard C++ Here's a step-by-step guide on how to define and use user-defined exceptions in C++:<\/p>\n\n\n\n Step 1: Define your custom exception class<\/p>\n\n\n Step 2: Throw the user-defined exception In this example, we defined a custom Step 3: Handle the user-defined exception User-defined exceptions are helpful for providing meaningful error messages and handling specific error scenarios in your code. You can create multiple custom exception classes to represent different types of errors, which allows for better organization and readability in your exception handling.<\/p>\n\n\n\n C++ standard exceptions provide a list of standard exceptions defined in <exception> which we can use in our programs. In C++, you can create your own user-defined exceptions to handle specific error conditions in your code. User-defined exceptions allow you to define custom exception types that inherit from the standard C++ Here's a step-by-step guide on how to define and use user-defined exceptions in C++:<\/p>\n\n\n\n Step 1: Define your custom exception class<\/p>\n\n\n Step 2: Throw the user-defined exception In this example, we defined a custom Step 3: Handle the user-defined exception User-defined exceptions are helpful for providing meaningful error messages and handling specific error scenarios in your code. You can create multiple custom exception classes to represent different types of errors, which allows for better organization and readability in your exception handling.<\/p>\n\n\n\n This brings us to the end of the blog on Exception Handling in C++. Hope this helps you to up-skill your C++ skills. To learn more about programming and other related concepts, check out the courses on Great Learning Academy<\/a>. <\/p>\n\n\n\n Also, if you are preparing for Interviews, check out these Interview Questions for C++<\/a> to ace it like a pro<\/p>\n\n\n\nWhat is Exception Handling in C++? <\/strong><\/h2>\n\n\n\n
\n
When a critical error occurs during program execution, you can use the throw<\/code> statement to raise an exception. It usually takes an object as an argument, which serves as the representation of the error.<\/li>\n<\/ol>\n\n\n\n#include <iostream>\n\nvoid someFunction(int value) {\n if (value == 0)\n throw std::runtime_error("Error: Division by zero!");\n \/\/ ... other code ...\n}\n<\/pre><\/div>\n\n\n\n
To catch an exception, you use a try<\/code> block. The code that might raise an exception is placed inside the try<\/code> block. If an exception is thrown within the try<\/code> block, the program will immediately jump to the corresponding catch<\/code> block.<\/li>\n<\/ol>\n\n\n\nint main() {\n try {\n int x = 10;\n int y = 0;\n someFunction(x \/ y);\n } catch (const std::runtime_error& e) {\n std::cout << "Exception caught: " << e.what() << std::endl;\n }\n \/\/ ... other code ...\n return 0;\n}\n<\/pre><\/div>\n\n\n\n
The catch<\/code> block handles the caught exception. It specifies the type of exception it can catch in parentheses, followed by a block of code that handles the exceptional condition.<\/li>\n\n\n\n
You can have multiple catch<\/code> blocks to handle different types of exceptions. The first catch<\/code> block that matches the thrown exception's type will be executed, and the others will be skipped.<\/li>\n<\/ol>\n\n\n\ntry {\n \/\/ code that may throw exceptions\n} catch (const SomeExceptionType& e) {\n \/\/ handle SomeExceptionType\n} catch (const AnotherExceptionType& e) {\n \/\/ handle AnotherExceptionType\n} catch (...) {\n \/\/ handle any other exception that is not caught by previous catch blocks\n}\n<\/pre><\/div>\n\n\n\n
Exception safety refers to the concept of ensuring that a program's state remains consistent even if an exception is thrown. Writing exception-safe code is essential to prevent resource leaks and maintain data integrity.<\/li>\n<\/ol>\n\n\n\n#include <iostream>\n\nint main() {\n try {\n \/\/ Code that may throw an exception\n int numerator = 10;\n int denominator = 0;\n int result = numerator \/ denominator;\n\n std::cout << \"Result: \" << result << std::endl;\n }\n catch (const std::exception& e) {\n std::cout << \"Exception occurred: \" << e.what() << std::endl;\n }\n\n return 0;\n}\n<\/code><\/pre>\n\n\n\nWhy Exception Handling? <\/strong><\/h2>\n\n\n\n
\n
Basic Keywords in Exception Handling: <\/strong><\/h3>\n\n\n\n
\n
What is try throw catch in c++?<\/strong><\/h3>\n\n\n\n
try<\/code>, throw<\/code>, and catch<\/code> are keywords used for exception handling. Exception handling allows developers to handle errors or exceptional situations gracefully and provide a structured way to manage unexpected conditions during the execution of a program.<\/p>\n\n\n\n\n
catch<\/code>: The catch<\/code> block follows the try<\/code> block and is used to catch and handle exceptions. It contains code that executes when a specific type of exception is thrown within the associated try<\/code> block. Multiple catch<\/code> blocks can be used for different exception types.<\/li>\n<\/ol>\n\n\n\ntry {\n \/\/ Code that might throw an exception\n \/\/ If an exception is thrown, control jumps to the corresponding catch block\n} catch (ExceptionType1 e) {\n \/\/ Code to handle ExceptionType1\n} catch (ExceptionType2 e) {\n \/\/ Code to handle ExceptionType2\n} catch (...) {\n \/\/ Catch-all block to handle any other unhandled exceptions (optional)\n}\n\n<\/pre><\/div>\n\n\nHow try-catch in c++ works?<\/strong><\/h3>\n\n\n\n
try-catch<\/code> mechanism. It allows you to catch and handle exceptions that occur during the execution of your program. The try<\/code> block contains the code that might throw an exception, and it handles the exception if it occurs. Here's how it works:<\/p>\n\n\n\n\n
try<\/code> block. If an exception occurs within this block, the execution of the code within the try<\/code> block is immediately stopped, and the program looks for a matching catch<\/code> block to handle the exception.<\/li>\n\n\n\ncatch<\/code> block. A matching catch<\/code> block is one that can handle the specific type of exception that was thrown. If a matching catch<\/code> block is found, the code within that block is executed.<\/li>\n\n\n\ncatch<\/code> block is found within the current scope, the program moves up the call stack, searching for an appropriate catch<\/code> block in the calling functions. This process continues until a matching catch<\/code> block is found or until the program reaches the top level of the program (i.e., main()<\/code> function).<\/li>\n\n\n\ncatch<\/code> block is found, the code within that block is executed, and the program continues executing from the point immediately after the try-catch<\/code> block.<\/li>\n<\/ol>\n\n\n\ntry-catch<\/code>:<\/strong><\/p>\n\n\n\n#include <iostream>\n\nint main() {\n try {\n \/\/ Code that might throw an exception\n int num1, num2;\n std::cout << \"Enter two numbers: \";\n std::cin >> num1 >> num2;\n\n if (num2 == 0) {\n throw std::runtime_error(\"Divide by zero exception\");\n }\n\n int result = num1 \/ num2;\n std::cout << \"Result: \" << result << std::endl;\n }\n catch (const std::exception& e) {\n \/\/ Exception handling code\n std::cout << \"Exception caught: \" << e.what() << std::endl;\n }\n\n return 0;\n}\n<\/code><\/pre>\n\n\n\n#include <iostream>\n\nint main() {\n try {\n \/\/ Code that may throw an exception\n int numerator = 10;\n int denominator = 0;\n int result = numerator \/ denominator;\n\n std::cout << \"Result: \" << result << std::endl;\n }\n catch (const std::runtime_error& e) {\n std::cout << \"Runtime error occurred: \" << e.what() << std::endl;\n }\n catch (const std::exception& e) {\n std::cout << \"Exception occurred: \" << e.what() << std::endl;\n }\n\n return 0;\n}\n<\/code><\/pre>\n\n\n\ncatch<\/code> block to handle a specific type of exception, std::runtime_error<\/code>, before catching the more general std::exception<\/code>. The specific exception types should be caught before the more general ones.<\/p>\n\n\n\n#include <iostream>\n#include <stdexcept>\n\nvoid checkAge(int age) {\n if (age < 0) {\n throw std::invalid_argument(\"Age cannot be negative.\");\n }\n else if (age < 18) {\n throw std::out_of_range(\"You must be at least 18 years old.\");\n }\n else {\n std::cout << \"Access granted.\" << std::endl;\n }\n}\n\nint main() {\n try {\n int userAge = 15;\n checkAge(userAge);\n }\n catch (const std::exception& e) {\n std::cout << \"Exception occurred: \" << e.what() << std::endl;\n }\n\n return 0;\n}\n<\/code><\/pre>\n\n\n\ncheckAge<\/code> the function throws custom exceptions, std::invalid_argument<\/code> and std::out_of_range<\/code>, based on the age value provided. The try<\/code> block calls the checkAge<\/code> function, and if an exception is thrown, it is caught and handled in the catch<\/code> block.<\/p>\n\n\n\nHow to use try-catch in c++?<\/strong><\/h3>\n\n\n\n
In the Try block, the \"throw\" keyword throws an exception when the code detects a problem, which lets us create a custom error.
Now \"catch\" keyword comes into a picture i.e. \"catch\" keyword allows you to define a block of code to be executed if an error occurs in the try block. <\/p>\n\n\n\nHow do you catch exceptions in C++?<\/strong><\/h3>\n\n\n\n
How to throw an exception in c++?<\/strong><\/h3>\n\n\n\n
You can create your own custom exception class by inheriting from the standard std::exception class or any of its derived classes. This step is optional, as you can also use the standard exception classes provided by the C++ Standard Library.<\/p>\n\n\n\n
Use the throw keyword followed by the exception object you want to throw. If you have created a custom exception class, you can instantiate an object of that class and pass it to the throw statement.<\/p>\n\n\n\n
To handle the thrown exception, you need to enclose the code that may throw an exception within a try-catch block. The catch block will catch the thrown exception and allow you to handle it gracefully.<\/p>\n\n\n\n#include <iostream>\n\n\/\/ Custom exception class (optional)\nclass MyException : public std::exception {\npublic:\n virtual const char* what() const noexcept override {\n return \"My custom exception occurred!\";\n }\n};\n\nint main() {\n try {\n int age;\n std::cout << \"Enter your age: \";\n std::cin >> age;\n\n if (age < 0) {\n \/\/ Throw a custom exception\n throw MyException();\n }\n\n \/\/ Other code that may throw exceptions\n \/\/ ...\n\n } catch (const MyException& ex) {\n std::cout << \"Caught custom exception: \" << ex.what() << std::endl;\n } catch (const std::exception& ex) {\n \/\/ Catch other exceptions derived from std::exception\n std::cout << \"Caught standard exception: \" << ex.what() << std::endl;\n } catch (...) {\n \/\/ Catch any other unhandled exceptions (not recommended, but can be useful for debugging)\n std::cout << \"Caught unknown exception.\" << std::endl;\n }\n\n return 0;\n}\n<\/code><\/pre>\n\n\n\n
In this example, if the user enters a negative age, the MyException object will be thrown, and it will be caught by the corresponding catch block.<\/p>\n\n\n\nC++ Standard Exceptions<\/strong><\/h2>\n\n\n\n
std::exception<\/code> class or any of its derived classes. This enables you to throw and catch specific exception types that represent different error situations.<\/p>\n\n\n\n\n#include <exception>\n#include <string>\n\nclass MyException : public std::exception {\npublic:\n MyException(const std::string& message) : message_(message) {}\n\n \/\/ Override the what() method to provide error description\n const char* what() const noexcept override {\n return message_.c_str();\n }\n\nprivate:\n std::string message_;\n};\n<\/pre><\/div>\n\n\n
You can throw the custom exception in your code when a specific error condition is encountered. For example:<\/p>\n\n\n\n#include <iostream>\n\ndouble divideNumbers(double numerator, double denominator) {\n if (denominator == 0) {\n throw MyException("Division by zero is not allowed.");\n }\n return numerator \/ denominator;\n}\n\nint main() {\n try {\n double result = divideNumbers(10.0, 0.0);\n std::cout << "Result: " << result << std::endl;\n } catch (const MyException& ex) {\n std::cout << "Error: " << ex.what() << std::endl;\n }\n\n return 0;\n}\n<\/pre><\/div>\n\n\nMyException<\/code> class and used it to throw an exception when dividing by zero in the divideNumbers<\/code> function. In the main<\/code> function, we catch the exception and handle it by printing the error message.<\/p>\n\n\n\n
When an exception is thrown, you can catch it using a try<\/code> block and handle it with a corresponding catch<\/code> block. In this example, we catch MyException<\/code> and print its error message using the what()<\/code> method.<\/p>\n\n\n\nWhat is C++ Standard Exceptions?<\/h3>\n\n\n\n
These exceptions are arranged in a parent-child class hierarchy:<\/strong><\/p>\n\n\n\nUser-Defined Exceptions <\/strong><\/h2>\n\n\n\n
std::exception<\/code> class or any of its derived classes. This enables you to throw and catch specific exception types that represent different error situations.<\/p>\n\n\n\n\n#include <exception>\n#include <string>\n\nclass MyException : public std::exception {\npublic:\n MyException(const std::string& message) : message_(message) {}\n\n \/\/ Override the what() method to provide error description\n const char* what() const noexcept override {\n return message_.c_str();\n }\n\nprivate:\n std::string message_;\n};\n<\/pre><\/div>\n\n\n
You can throw the custom exception in your code when encountering a specific error condition. For example:<\/p>\n\n\n\n#include <iostream>\n\ndouble divideNumbers(double numerator, double denominator) {\n if (denominator == 0) {\n throw MyException("Division by zero is not allowed.");\n }\n return numerator \/ denominator;\n}\n\nint main() {\n try {\n double result = divideNumbers(10.0, 0.0);\n std::cout << "Result: " << result << std::endl;\n } catch (const MyException& ex) {\n std::cout << "Error: " << ex.what() << std::endl;\n }\n\n return 0;\n}\n<\/pre><\/div>\n\n\nMyException<\/code> class and used it to throw an exception when dividing by zero in the divideNumbers<\/code> function. In the main<\/code> function, we catch the exception and handle it by printing the error message.<\/p>\n\n\n\n
When an exception is thrown, you can catch it using a try<\/code> block and handle it with a corresponding catch<\/code> block. In this example, we catch MyException<\/code> and print its error message using the what()<\/code> method.<\/p>\n\n\n\n