CSC 2045 Exception Handling

CSC 2045 Exception Handling

• Exception handling in C++ uses try, throw, and catch keywords.
• The try block defines code to be tested for errors.
• The throw keyword is used to create a custom error when a problem is detected. throw is for explicit error handling situations.
• The catch block defines code to execute if an error occurs in the try block.
• try and catch keywords are used in pairs.
• Exceptions force calling code to recognize and handle error conditions (unhandled exceptions stop execution).
• Exceptions jump to the point in the call stack that can handle the error.
• Intermediate functions can let exceptions propagate if they don't have a handler. Exceptions do not inherently require coordination with all other layers of the program, unless necessary to ensure clean cleanup.
• The exception stack-unwinding mechanism destroys objects in scope.
• Exceptions enable a clean separation between detecting and handling errors.
• Standard Exceptions: C++ provides a consistent way to handle errors with a standard library of exceptions. All exceptions inherit from the base std::exception class. The what() virtual function provides a textual description of the exception (can be overridden for more specific error information). Common standard exceptions are logic_error, invalid_argument, length_error, out_of_range, bad_cast, runtime_error, overflow_error, underflow_error, bad_alloc, ios_base::failure.
• Multiple exception handlers via catch blocks allow for various error conditions to be handled. A catch(...) handler can catch any type of exception.
• Using multiple catch expressions allows capturing different types of errors. Error handling with catch(...) acts as a general handler.
• String to Number Conversions: Errors can occur during string-to-number conversion, including cases where a string doesn't represent a valid number, or numbers are out of range. Extra data in a string after the number can also lead to errors during conversion.
• std::istream and error flags (e.g. badbit, failbit) are used for reporting string-to-number conversion failures efficiently.

Objectives

• Understand exceptions, write code to handle them, recognize common exceptions, and diagnose them in programs.
• Be familiar with standard coding standards and conventions, and write clean, maintainable, readable, and secure code. This includes rules for safe and reliable development, and eliminating undefined program behaviors and vulnerabilities.
• Proper exception handling is key to building robust programs that gracefully handle errors. Clean separation and well-organized error handling are crucial for maintainable and safe programs.

Agenda: Week 07

• Exception Handling & Syntax
• Exception Handling Guidelines
• SEI Handle all Exceptions
• Review Exception Handling
• Detect Errors (String to Number)
  • Detect issues with converting strings to numbers (number format, range, extra characters, and valid number detection). Error checking is necessary.
• When NOT and When TO use Exception Handling
• Exception Handling & Efficiency
• Various exception handling situations and types are addressed during the week. Exceptions are for specific error conditions, not for regular program flow. Exceptional handling improves reliability.

Exception Handling

• Exceptions force calling code to recognize errors and handle exceptions.
• Unhandled exceptions halt program execution.
• Exceptions jump to the point in the call stack to manage the error.
• Exceptions do not require coordination with all other layers of the program, unless necessary to ensure clean cleanup.
• The system destroys all objects in scope when an exception is thrown.
• Exception Handling provides a clear and robust way to handle errors, improving code structure and preventing crashes or unexpected behaviors. Exception handling is useful for error conditions and unusual cases.

Basic Exception Handling

• Exception handling in C++ involves three keywords: try, throw, and catch.
  • try: Defines a block of code to be tested for errors.
  • throw: Throws an exception when a problem is found, creating a custom error. Throwing exceptions is an explicit step.
  • catch: Defines a block of code to execute if an error occurs in the try block.

Guidelines for Exception Handling

• Use exceptions when error handling code is separate from the part of the code that detects the error (intervening function calls).
• Use exceptions to check for potential errors (e.g., input validation on parameters in public functions).
• Exceptions should be thrown by value and caught by reference to avoid unnecessary copies (avoiding object slicing).
• Avoid catching a derived exception as a base class object to prevent object slicing.
• Do not catch exceptions that your handler cannot handle effectively.
• Using exceptions for error handling can improve code clarity and maintainability. Exception handling with structured code makes programs more robust and easier to manage. It is useful to catch errors carefully.

Exception Handling (ISOCPP)

• Using exceptions for error handling simplifies, cleans, and prevents error omissions in code, making it easier to test and debug.
• Error handling and normal code mixing (using errno and if-statements) does not make the handling clear, and mixing makes the code harder to maintain and troubleshoot (spaghetti code).
• Exceptions improve code readability and robustness. Separating exception handling makes the flow of control easier to manage, unlike intertwined if-statements in error handling code. Exceptions help separate error handling from the normal program flow.

Exception Handling (Cplusplus)

• Exceptions allow reaction to and control of runtime errors, especially through special functions (handlers).
• Portions of code under inspection (enclosed in try blocks) execute handlers when an unusual circumstance (exception) is encountered.
  • If no error is thrown, the code runs normally and handlers are skipped. The catch block executes only if a throw is enacted.
• Exceptions represent unusual cases and should not be the default way for normal program flow.

Multiple Exception Handlers

• Multiple catch blocks (expressions) can be chained, each with different parameter types, defining specific exception handling for various situations.
• Using ... as the parameter in a catch block allows capturing any type of exception (useful as a default handler). This creates a general handler for all types of exceptions, useful when the specific type of exception is unknown.
• Exception handling using multiple catch blocks is efficient and versatile, enabling more nuanced error handling. Careful consideration is crucial for error handling to be effective in code. Using catch (...) can also avoid having too many catch blocks.

Handling All Exceptions

• Exceptions thrown by an application require a matching handler.
  • Even if errors cannot be gracefully recovered from, catching them ensures proper stack unwinding and allows the program to manage external resources before exit.
• One solution is for the main() function to catch all, encompassing errors within a try-catch block.
• This ensures a regulated program termination method, but doesn't necessarily allow for recovery from the exception—it should be for ensuring termination and cleanup.
• Handling all exceptions improves code robustness. Enclosing program code in try-catch blocks is necessary in some situations.

Non-Compliant Exception Handling

• Failure to catch exceptions can result in std::terminate() being called (forced program termination).
  • This can cause uncontrolled program termination if not caught.
• Unhandled exceptions disrupt the program if not correctly handled. Robust programs handle exceptions. Program termination should be considered in handling exceptions.

Compliant Exception Handling

• main() function handles all exceptions for stack unwinding and graceful management of external resources (e.g. file handles).
• The code example illustrates this using a try-catch block, making robust programs. main function must be a central point for handling exceptions.
• Proper structuring ensures smooth program termination even during unexpected events.

Handling Exceptions for Threads

• The thread entry point (e.g. thread_start) needs to catch exceptions—if possible— to prevent program termination. This prevents the thread from crashing, and an exception within a thread likely does not terminate the entire program.
• If an exception occurs within the thread, ensure appropriate thread termination rather than the entire program termination. Robust programs handle exceptions within threads or other functions.
• Robust thread handling requires exception safety to maintain program consistency. Proper handling to ensure thread safety.

Review Exception Handling

• Robust code benefits significantly from error handling and error recovery techniques.
• Making error-handling code easier to maintain and separating it from the main code is beneficial when handling errors. Errors need to be addressed to prevent problems.
• Errors should not be silently ignored. Exceptions are best for truly exceptional (unusual) conditions. Exception handling enhances code quality.

Standard Exceptions

• Standard exceptions (C++) provide consistent interfaces for handling errors through throw expressions.
• All standard library exceptions inherit from std::exception.
• A crucial function in std::exception is what(). It returns a null-terminated string description that allows derived exception classes to customize exception messages.
• C++'s support for standard exceptions is valuable for effective software development. Common exceptions include logic_error, invalid_argument, length_error, out_of_range, bad_cast, runtime_error, overflow_error, underflow_error, bad_alloc, ios_base::failure.

Detect Errors: String to Number

• Converting strings to numbers can generate errors.
  • The string might not contain a valid number.
  • Errors or problems arise if the number is out of range (using a string as input can result in out-of-range numbers).
  • Extra data could be present after the actual number, causing errors.
• Error handling is crucial during string-to-numeric conversions, especially when using formatted input streams (std::istream) to prevent unexpected results or crashes. Care is crucial to handle errors robustly in such situations.
• Carefully planned error handling prevents unexpected program behavior during string-to-number conversions. Correct handling of errors is needed.

Detect Errors : String to Number - Non-Compliant

• Converting multiple numeric values can lead to unexpected results if invalid input is received. Unhandled inputs lead to unpredictable program behavior, especially in string-to-number conversions.
• If non-numeric or out of range input is encountered, the behavior of the program could be unpredictable.
• Errors are handled unrobustly in the non-compliant version, and code behavior is unpredictable; structured error handling is paramount for effective code.

Detect Errors: String to Number - Compliant

• Using exceptions for conversion failures helps handle errors during string-to-number conversions (e.g., using try...catch).
  • It also leverages features of input streams to detect conversion problems or integrity problems when converting strings to numbers (e.g., badbit or failbit flags).
  • Handling invalid or inappropriate string formats (like unexpected characters or format) prevents unusual program behavior or crashes.
• Using exceptions makes code more robust and less prone to errors when dealing with input/output problems like incorrect input.

When NOT to Use Exception Handling

• Exceptions are not the solution for every problem and overusing them can introduce challenges (e.g. overhead, or confusing code structure).
• Exceptions are not necessary for regular asynchronous events, benign error conditions, or standard flow controls, as they add complexity.
• You aren't obligated to use exceptions.
• Use exceptions for situations demonstrating non-standard behavior.
• Use exceptions for situations when errors are extremely unusual or complex.

When TO Use Exception Handling

• Use standard exceptions as a starting point.
• Wrap functions (e.g., C library calls) that handle errors as exceptions (instead of traditional error codes) to make error handling simpler and easier to manage, particularly to aid in debugging, and improving long-term code manageability.
• If traditional error handling makes things more complicated, consider exceptions. They can enhance clarity and handling of exceptional (unusual) conditions.
• Using exceptions can lead to more robust, easier to debug code, and safer code (e.g., avoiding hard-to-debug error codes).
• Carefully consider the situation to determine the correct error handling (e.g. avoiding exceptions for easily caught and debugged errors).

Exception Handling & Efficiency

• Throwing exceptions introduces runtime overhead.
• It's not recommended for typical flow-of-control operations because of this overhead.
• Exceptions are for unusual circumstances—not ordinary program flow. Exceptions should be reserved for unusual cases that require more advanced processing than standard error codes.
• Handling exceptions involves a call to a special function that reverses (or retraces) the call stack to find the location of the error (stack unwinding).
• The compiler creates extra information on the call stack to aid in stack unwinding and error retrieval.
• Exception handling should be used judiciously to avoid performance degradation. Use exceptions only sparingly. Consider other possible error handling techniques when appropriate. Excessive use of exceptions may negatively impact program performance.