Win32 Exception Handling

This section details the mechanisms for handling exceptions within the Windows operating system API.

Overview

Exception handling in Windows is crucial for robust application development. It allows your program to gracefully respond to unexpected events or error conditions that would otherwise cause a crash. The primary mechanisms provided by the Win32 API involve Structured Exception Handling (SEH).

Structured Exception Handling (SEH)

SEH is a C++-like language extension that provides a structured way to handle both hardware exceptions (like division by zero or access violations) and software-generated exceptions.

Key SEH Constructs:

• __try / __except: The core of SEH. The __try block contains code that might raise an exception. The __except block contains the exception handler.
• __finally: A block that is guaranteed to execute, regardless of whether an exception occurred or not. This is useful for cleanup operations.

The __try / __except Block

The __except block evaluates an expression that determines how to handle the exception. Common filter expressions include:

• EXCEPTION_EXECUTE_HANDLER: Executes the code within the __except block.
• EXCEPTION_CONTINUE_SEARCH: Continues searching for an exception handler up the call stack.
• EXCEPTION_CONTINUE_EXECUTION: Attempts to resume execution at the point where the exception occurred (use with extreme caution).

#include <windows.h>
#include <iostream>

int main() {
    int numerator = 10;
    int denominator = 0;
    int result;

    __try {
        result = numerator / denominator; // This will cause an exception
        std::cout << "Result: " << result << std::endl; // This line won't be reached
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        std::cerr << "An exception occurred: Division by zero!" << std::endl;
        // Perform cleanup or alternative actions here
    }

    std::cout << "Program continues after exception handling." << std::endl;
    return 0;
}
                

The __try / __finally Block

The __finally block is always executed, making it ideal for releasing resources, closing files, or unlocking critical sections.

#include <windows.h>
#include <iostream>
#include <fstream>

HANDLE hFile = INVALID_HANDLE_VALUE;

void ProcessFile() {
    __try {
        hFile = CreateFile(L"myfile.txt", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if (hFile == INVALID_HANDLE_VALUE) {
            // Raise a software exception to be caught by __except
            RaiseException(1, 0, 0, NULL);
        }
        // Write to file...
        std::cout << "File opened and processed successfully." << std::endl;
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        std::cerr << "Error during file processing." << std::endl;
        // The __finally block will still execute
    }
    __finally {
        if (hFile != INVALID_HANDLE_VALUE) {
            CloseHandle(hFile);
            std::cout << "File handle closed in __finally block." << std::endl;
        }
    }
}

int main() {
    ProcessFile();
    return 0;
}
                

RaiseException Function

You can programmatically raise a software exception using the RaiseException function. This is useful for signaling error conditions within your application.

Exception Codes

Windows defines a set of common exception codes. Custom applications can define their own codes as well.

• EXCEPTION_ACCESS_VIOLATION (0xC0000005): Attempted to access memory that was not allowed.
• EXCEPTION_INT_DIVIDE_BY_ZERO (0xC0000094): Integer division by zero.
• EXCEPTION_ILLEGAL_INSTRUCTION (0xC00000B7): Attempted to execute an illegal instruction.

Further Reading

• Microsoft Docs: Structured Exception Handling
• Microsoft Docs: Exception Codes