Software systems do not always behave perfectly during execution. A banking application may lose connection to the server, a file may fail to open, or a user may enter invalid data. These situations occur while the program is running and can interrupt the normal flow of execution. Such abnormal runtime situations are called exceptions.<\/p>\n\n\n\n
If these situations are not handled properly, the program may terminate unexpectedly. Modern software systems therefore use exception handling mechanisms to detect errors and respond safely instead of crashing completely.<\/p>\n\n\n\n
Consider an ATM system. If the machine temporarily loses communication with the bank server, the system does not suddenly shut down. Instead, it displays a message such as:<\/p>\n\n\n\n
Unable to process your request.\nPlease try again later.<\/code><\/pre>\n\n\n\nThis controlled response is an example of exception handling.<\/p>\n\n\n\n
Why Traditional Error Handling Was Not Enough<\/h1>\n\n\n\n
Before exception handling was introduced, programmers usually handled errors using return values or status codes.<\/p>\n\n\n\n
Consider the following example:<\/p>\n\n\n\n
#include <iostream>\nusing namespace std;\n\nint divide(int a, int b)\n{\n if(b == 0)\n return -1;\n\n return a \/ b;\n}\n\nint main()\n{\n cout << divide(10, 0);\n\n return 0;\n}<\/code><\/pre>\n\n\n\nIn this program, the function returns -1<\/code> if division by zero occurs. Although this approach appears simple, it creates several problems. A programmer may forget to check the returned value, or -1<\/code> itself may actually be a valid answer in another situation. As software systems grow larger, mixing error-handling logic with normal program logic makes programs difficult to understand and maintain.<\/p>\n\n\n\nTo solve this issue, C++ introduced exception handling.<\/p>\n\n\n\n
Basic Idea of Exception Handling<\/h1>\n\n\n\n
Exception handling in C++ is based on three important keywords:<\/p>\n\n\n\n
\ntry<\/code><\/li>\n\n\n\nthrow<\/code><\/li>\n\n\n\ncatch<\/code><\/li>\n<\/ul>\n\n\n\nThe idea is straightforward. The risky code is placed inside a try<\/code> block. If an abnormal condition occurs, the program generates an exception using throw<\/code>. The exception is then received and handled inside a catch<\/code> block.<\/p>\n\n\n\nThe general structure looks like this:<\/p>\n\n\n\n
try\n{\n \/\/ risky code\n}\ncatch(...)\n{\n \/\/ handling code\n}<\/code><\/pre>\n\n\n\nThe try<\/code> block contains the statements that may generate problems. The catch<\/code> block handles the exception so that the program can continue safely.<\/p>\n\n\n\nFirst Example \u2014 Division by Zero<\/h1>\n\n\n\n
Let us understand the complete process through a simple program.<\/p>\n\n\n\n
#include <iostream>\nusing namespace std;\n\nint main()\n{\n int a, b;\n\n cout << \"Enter two numbers: \";\n cin >> a >> b;\n\n try\n {\n if(b == 0)\n throw \"Division by zero is not allowed.\";\n\n cout << \"Result = \" << a \/ b << endl;\n }\n\n catch(const char* msg)\n {\n cout << \"Error: \" << msg << endl;\n }\n\n return 0;\n}<\/code><\/pre>\n\n\n\nIn this program, the user enters two numbers. Before division is performed, the program checks whether the denominator is zero. If the denominator becomes zero, the program uses the throw<\/code> statement to generate an exception.<\/p>\n\n\n\nAs soon as the exception is thrown, the normal execution of the try<\/code> block stops immediately. Control jumps directly to the catch<\/code> block, where the error message is displayed.<\/p>\n\n\n\nUnderstanding Program Flow<\/h1>\n\n\n\n
Students often misunderstand how control moves during exception handling. It is therefore important to understand the execution flow carefully.<\/p>\n\n\n\n
Program starts\n \u2193\ntry block begins\n \u2193\nerror occurs\n \u2193\nthrow statement executes\n \u2193\nremaining try block skipped\n \u2193\ncatch block executes\n \u2193\nprogram continues safely<\/code><\/pre>\n\n\n\nOnce an exception is thrown, the remaining statements inside the try<\/code> block are ignored. The program immediately searches for a matching catch<\/code> block.<\/p>\n\n\n\nThrowing Different Types of Exceptions<\/h1>\n\n\n\n
In C++, exceptions are actually data values or objects. Different types of data can be thrown depending on the situation.<\/p>\n\n\n\n
throw 10;\nthrow 3.14;\nthrow \"Invalid Input\";<\/code><\/pre>\n\n\n\nBecause exceptions can have different data types, C++ allows multiple catch<\/code> blocks to handle different situations.<\/p>\n\n\n\nMultiple catch Blocks<\/h1>\n\n\n\n
Consider the following example:<\/p>\n\n\n\n
#include <iostream>\nusing namespace std;\n\nint main()\n{\n try\n {\n throw 10;\n }\n\n catch(int x)\n {\n cout << \"Integer exception caught.\" << endl;\n }\n\n catch(double y)\n {\n cout << \"Double exception caught.\" << endl;\n }\n\n catch(...)\n {\n cout << \"Unknown exception caught.\" << endl;\n }\n\n return 0;\n}<\/code><\/pre>\n\n\n\nHere, the program throws an integer value. The catch(int x)<\/code> block handles the exception because its type matches the thrown value.<\/p>\n\n\n\nThe catch(...)<\/code> block is called the catch-all handler. It handles any exception type that does not match earlier catch blocks. For this reason, it should always appear at the end.<\/p>\n\n\n\nException Handling with Functions<\/h1>\n\n\n\n
In real software systems, exceptions usually occur inside functions rather than directly inside main()<\/code>.<\/p>\n\n\n\nConsider the following example:<\/p>\n\n\n\n
#include <iostream>\nusing namespace std;\n\nvoid divide(int a, int b)\n{\n if(b == 0)\n throw \"Division by zero.\";\n\n cout << \"Result = \" << a \/ b << endl;\n}\n\nint main()\n{\n try\n {\n divide(10, 0);\n }\n\n catch(const char* msg)\n {\n cout << msg << endl;\n }\n\n return 0;\n}<\/code><\/pre>\n\n\n\nThe function divide()<\/code> throws an exception when division by zero occurs. The exception is not handled inside the function itself. Instead, it is handled in main()<\/code>.<\/p>\n\n\n\nThis demonstrates an important concept called exception propagation.<\/p>\n\n\n\n
Exception Propagation<\/h1>\n\n\n\n
When a function cannot handle an exception, the exception automatically moves upward to the calling function. This process is known as exception propagation.<\/p>\n\n\n\n
Consider the following execution chain:<\/p>\n\n\n\n
main()\n \u2193\nlogin()\n \u2193\ndatabase()\n \u2193\nfile()<\/code><\/pre>\n\n\n\nIf file()<\/code> throws an exception and does not handle it, the exception travels upward through database()<\/code>, then login()<\/code>, until some function finally catches it.<\/p>\n\n\n\nThe following example demonstrates this process clearly.<\/p>\n\n\n\n
#include <iostream>\nusing namespace std;\n\nvoid level3()\n{\n throw \"File not found!\";\n}\n\nvoid level2()\n{\n level3();\n}\n\nvoid level1()\n{\n level2();\n}\n\nint main()\n{\n try\n {\n level1();\n }\n\n catch(const char* msg)\n {\n cout << \"Caught in main: \" << msg << endl;\n }\n\n return 0;\n}<\/code><\/pre>\n\n\n\nThe exception originates in level3()<\/code>. Since none of the intermediate functions handle it, the exception eventually reaches main()<\/code>.<\/p>\n\n\n\nStandard Exception Classes in C++<\/h1>\n\n\n\n
C++ already provides many built-in exception classes through the Standard Library. These classes help programmers handle common runtime problems in a professional way.<\/p>\n\n\n\n
Some commonly used standard exceptions are:<\/p>\n\n\n\n
runtime_error\nout_of_range\ninvalid_argument\nbad_alloc<\/code><\/pre>\n\n\n\nThese classes are derived from the base class std::exception<\/code>.<\/p>\n\n\n\nUsing Standard Exceptions<\/h1>\n\n\n\n
Consider the following example using out_of_range<\/code>.<\/p>\n\n\n\n#include <iostream>\n#include <vector>\nusing namespace std;\n\nint main()\n{\n vector<int> nums = {10, 20, 30};\n\n try\n {\n cout << nums.at(5);\n }\n\n catch(const out_of_range &e)\n {\n cout << \"Exception: \" << e.what() << endl;\n }\n\n return 0;\n}<\/code><\/pre>\n\n\n\nThe function vector.at()<\/code> automatically throws an exception if the index is invalid. The what()<\/code> function returns a descriptive error message associated with the exception object.<\/p>\n\n\n\nThis approach is much cleaner and more professional than manually checking every condition.<\/p>\n\n\n\n
Custom Exceptions<\/h1>\n\n\n\n
Large software systems often require application-specific exceptions. For example, a banking system may need exceptions such as:<\/p>\n\n\n\n
LowBalanceException\nInvalidPINException\nAccountBlockedException<\/code><\/pre>\n\n\n\nThese custom exceptions make programs easier to understand and maintain.<\/p>\n\n\n\n
Creating a Simple Custom Exception<\/h1>\n\n\n\n
A custom exception can be created using a normal class.<\/p>\n\n\n\n
#include <iostream>\nusing namespace std;\n\nclass InvalidAge {};\n\nint main()\n{\n int age;\n\n cout << \"Enter age: \";\n cin >> age;\n\n try\n {\n if(age < 18 || age > 60)\n throw InvalidAge();\n\n cout << \"Valid age.\" << endl;\n }\n\n catch(InvalidAge)\n {\n cout << \"Invalid age entered.\" << endl;\n }\n\n return 0;\n}<\/code><\/pre>\n\n\n\nHere, the program throws an object of class InvalidAge<\/code> whenever the entered age falls outside the valid range.<\/p>\n\n\n\nProfessional Custom Exceptions<\/h1>\n\n\n\n
In professional C++ programming, custom exceptions are usually derived from std::exception<\/code>.<\/p>\n\n\n\n#include <iostream>\n#include <exception>\nusing namespace std;\n\nclass InvalidAge : public exception\n{\npublic:\n\n const char* what() const noexcept override\n {\n return \"Age must be between 18 and 60.\";\n }\n};\n\nint main()\n{\n int age;\n\n cout << \"Enter age: \";\n cin >> age;\n\n try\n {\n if(age < 18 || age > 60)\n throw InvalidAge();\n\n cout << \"Age accepted.\" << endl;\n }\n\n catch(const InvalidAge &e)\n {\n cout << e.what() << endl;\n }\n\n return 0;\n}<\/code><\/pre>\n\n\n\nThe what()<\/code> function provides a meaningful message describing the problem.<\/p>\n\n\n\nResource Management and Exception Safety<\/h1>\n\n\n\n
One of the biggest reasons for using exception handling is protecting system resources such as files, memory, database connections, and network sockets.<\/p>\n\n\n\n
Consider a situation where a program opens a file and then an exception occurs before the file is closed. Without proper handling, the file may remain open and cause resource leaks.<\/p>\n\n\n\n
C++ solves this problem using destructors and RAII (Resource Acquisition Is Initialization).<\/p>\n\n\n\n
File Handling Example<\/h1>\n\n\n\n#include <iostream>\n#include <fstream>\nusing namespace std;\n\nclass FileReader\n{\n ifstream file;\n\npublic:\n\n FileReader(const string &name)\n {\n file.open(name);\n\n if(!file)\n throw \"Unable to open file.\";\n }\n\n ~FileReader()\n {\n cout << \"Closing file...\" << endl;\n\n if(file.is_open())\n file.close();\n }\n\n void display()\n {\n string line;\n\n while(getline(file, line))\n cout << line << endl;\n }\n};\n\nint main()\n{\n try\n {\n FileReader fr(\"data.txt\");\n fr.display();\n }\n\n catch(const char* msg)\n {\n cout << msg << endl;\n }\n\n return 0;\n}<\/code><\/pre>\n\n\n\nEven if an exception occurs, the destructor executes automatically and safely closes the file.<\/p>\n\n\n\n
Smart Pointers and Exception Safety<\/h1>\n\n\n\n
Modern C++ provides smart pointers that automatically manage memory.<\/p>\n\n\n\n
#include <iostream>\n#include <memory>\nusing namespace std;\n\nint main()\n{\n try\n {\n unique_ptr<int> ptr(new int(10));\n\n cout << \"Value: \" << *ptr << endl;\n\n throw \"Some error occurred.\";\n }\n\n catch(const char* msg)\n {\n cout << msg << endl;\n }\n\n return 0;\n}<\/code><\/pre>\n\n\n\nEven though an exception occurs, the smart pointer automatically releases the allocated memory. This prevents memory leaks and improves program safety.<\/p>\n\n\n\n
Best Practices<\/h1>\n\n\n\n
Exception handling should be used carefully and professionally. Exceptions should represent abnormal situations rather than normal program logic. Meaningful error messages should always be provided so users and developers can easily understand the problem.<\/p>\n\n\n\n
It is also recommended to catch exceptions by reference because it improves efficiency and avoids unnecessary copying.<\/p>\n\n\n\n
Empty catch blocks should generally be avoided because silently ignoring exceptions can make debugging extremely difficult.<\/p>\n","protected":false},"excerpt":{"rendered":"
Software systems do not always behave perfectly during execution. A banking application may lose connection to the server, a file may fail to open, or a user may enter invalid data. These situations occur while the program is running and can interrupt the normal flow of execution. Such abnormal runtime situations are called exceptions. If these situations are not handled properly, the program may terminate unexpectedly. Modern software systems therefore use exception handling mechanisms to detect errors and respond safely…<\/p>\n