. Exception Handling Explained
Exception handling in C++ is a mechanism to handle runtime errors and unexpected conditions gracefully. It allows you to separate the error-handling code from the normal code, making your program more robust and easier to maintain. This section will cover the key concepts related to exception handling in C++.
Key Concepts
1. Throwing Exceptions
Exceptions are thrown using the throw keyword. When an exception is thrown, the normal flow of the program is interrupted, and the program looks for an appropriate handler to manage the exception.
Example:
#include <iostream>
using namespace std;
void divide(int a, int b) {
if (b == 0) {
throw "Division by zero error";
}
cout << "Result: " << a / b << endl;
}
int main() {
try {
divide(10, 0);
} catch (const char* msg) {
cerr << msg << endl;
}
return 0;
}
2. Catching Exceptions
Exceptions are caught using the try and catch blocks. The try block contains the code that might throw an exception, and the catch block contains the code to handle the exception.
Example:
#include <iostream>
using namespace std;
int main() {
try {
int age = 15;
if (age < 18) {
throw age;
}
cout << "Access granted - you are old enough.";
} catch (int myNum) {
cout << "Access denied - You must be at least 18 years old.\n";
cout << "Age is: " << myNum;
}
return 0;
}
3. Multiple Catch Blocks
You can have multiple catch blocks to handle different types of exceptions. This allows you to provide specific handling for different types of errors.
Example:
#include <iostream>
using namespace std;
int main() {
try {
int age = 15;
if (age < 18) {
throw age;
}
cout << "Access granted - you are old enough.";
} catch (int myNum) {
cout << "Access denied - You must be at least 18 years old.\n";
cout << "Age is: " << myNum;
} catch (const char* msg) {
cerr << msg << endl;
}
return 0;
}
4. Standard Exceptions
C++ provides a set of standard exceptions defined in the <stdexcept> header. These exceptions are derived from the std::exception class and can be used to handle common errors.
Example:
#include <iostream>
#include <stdexcept>
using namespace std;
int main() {
try {
int age = 15;
if (age < 18) {
throw invalid_argument("Access denied - You must be at least 18 years old.");
}
cout << "Access granted - you are old enough.";
} catch (invalid_argument& e) {
cerr << e.what() << endl;
}
return 0;
}
5. Custom Exceptions
You can create your own custom exceptions by deriving from the std::exception class or by creating a new class that can be thrown as an exception.
Example:
#include <iostream>
#include <stdexcept>
using namespace std;
class MyException : public exception {
public:
const char* what() const throw() {
return "My Custom Exception";
}
};
int main() {
try {
int age = 15;
if (age < 18) {
throw MyException();
}
cout << "Access granted - you are old enough.";
} catch (MyException& e) {
cerr << e.what() << endl;
}
return 0;
}
6. Exception Propagation
When an exception is thrown, it can propagate up the call stack until it is caught by an appropriate handler. If no handler is found, the program terminates.
Example:
#include <iostream>
using namespace std;
void func1() {
throw "Exception from func1";
}
void func2() {
func1();
}
int main() {
try {
func2();
} catch (const char* msg) {
cerr << msg << endl;
}
return 0;
}
7. Rethrowing Exceptions
You can rethrow an exception within a catch block using the throw keyword. This allows you to handle the exception partially and then let it propagate further.
Example:
#include <iostream>
using namespace std;
void func1() {
throw "Exception from func1";
}
void func2() {
try {
func1();
} catch (const char* msg) {
cerr << "Caught in func2: " << msg << endl;
throw; // Rethrow the exception
}
}
int main() {
try {
func2();
} catch (const char* msg) {
cerr << "Caught in main: " << msg << endl;
}
return 0;
}
8. Exception Specifications
Exception specifications were used in older C++ code to specify the types of exceptions that a function might throw. However, they are deprecated in modern C++ and are not recommended.
Example:
#include <iostream>
using namespace std;
void func() throw(int) {
throw 1;
}
int main() {
try {
func();
} catch (int e) {
cerr << "Caught exception: " << e << endl;
}
return 0;
}
9. Noexcept Specifier
The noexcept specifier is used to indicate that a function does not throw any exceptions. This can help the compiler optimize the code and provide better error messages.
Example:
#include <iostream>
using namespace std;
void func() noexcept {
// This function does not throw exceptions
cout << "No exceptions here!" << endl;
}
int main() {
func();
return 0;
}
Examples and Analogies
Example: Handling File I/O Exceptions
#include <iostream>
#include <fstream>
using namespace std;
int main() {
try {
ifstream file("nonexistent.txt");
if (!file) {
throw "File not found";
}
string line;
while (getline(file, line)) {
cout << line << endl;
}
} catch (const char* msg) {
cerr << msg << endl;
}
return 0;
}
Analogy: Exception Handling as a Safety Net
Think of exception handling as a safety net in a circus. When an acrobat performs a risky move, the safety net catches them if they fall. Similarly, in C++, exception handling catches errors and prevents the program from crashing.
Conclusion
Exception handling in C++ is a powerful mechanism that allows you to manage runtime errors and unexpected conditions gracefully. By understanding how to throw, catch, and handle exceptions, you can write more robust and maintainable code. Exception handling is essential for creating reliable and error-resistant applications.