Early Program Termination Techniques

void performCleanup() { std::cout << "Cleanup completed!\n"; }

int main() { std::cout << 1 << '\n'; performCleanup();

std::exit(0); // terminate and return status 0

// the following never execute
std::cout << 2 << '\n';

return 0;

}

Output:

1 Cleanup completed!

The statements after `std::exit()` never execute because the program has already terminated.

## std::exit() doesn't clean up local variables

When you call `std::exit()` explicitly, it does NOT clean up local variables in the current function or up the call stack. This can be dangerous if your program relies on destructors running.

<div class="danger">
<strong>Warning</strong><br>
`std::exit()` does not clean up local variables in the current function or calling functions.

</div>
## std::atexit

Since `std::exit()` terminates immediately, you might need to perform cleanup manually before exiting. Cleanup includes closing database connections, flushing file buffers, writing logs, deallocating memory, etc.

<div class="info">
<strong>As an Aside</strong><br>
Why bother cleaning up if the OS will clean it up anyway?

1. Consistency - you need cleanup while the program runs to avoid memory leaks. Cleaning up in some places but not others is error-prone.

2. Predictable behavior - unflushed file data might be lost on exit. Closed connections might need to send final packets. These operations should complete before shutdown.

Instead of manually calling cleanup functions before every `std::exit()`, use `std::atexit()` to register a cleanup function that runs automatically on program termination:

</div>
```cpp
#include <cstdlib>
#include <iostream>

void performCleanup()
{
    std::cout << "Cleanup completed!\n";
}

int main()
{
    std::atexit(performCleanup); // register cleanup function

    std::cout << 1 << '\n';

    std::exit(0); // cleanup will be called automatically

    // the following never execute
    std::cout << 2 << '\n';

    return 0;
}

Output:

1
Cleanup completed!

Notice we pass performCleanup (the function name), not performCleanup() (which would call it immediately).

Benefits of std::atexit():

• Call it once (probably in main())
• Cleanup happens automatically when std::exit() is called
• Also runs when main() returns normally
• You can register multiple cleanup functions (they execute in reverse order)

The cleanup function must take no parameters and return void.

Advanced note: In multithreaded programs, std::exit() can cause crashes because it cleans up static objects that other threads might be using. C++11 introduced std::quick_exit() and std::at_quick_exit() as safer alternatives. std::quick_exit() terminates normally but skips static object cleanup.

std::abort and std::terminate

C++ provides two other halt functions:

std::abort() causes abnormal termination - the program had an unusual runtime error and couldn't continue. For example, division by zero causes abnormal termination. std::abort() does no cleanup.

#include <cstdlib>
#include <iostream>

int main()
{
    std::cout << 1 << '\n';
    std::abort();

    // the following never execute
    std::cout << 2 << '\n';

    return 0;
}

std::terminate() is typically used with exceptions. It can be called explicitly, but is more often called implicitly when an exception isn't handled. By default, std::terminate() calls std::abort().

When should you use halts?

Almost never. Destroying local objects is crucial in C++ (especially with classes), and halts don't clean up local variables. Exceptions provide a better, safer mechanism for handling errors.

Summary

Halts are functions that terminate the program, either normally or abnormally, providing mechanisms to exit before main() returns.

Normal termination via std::exit() performs cleanup (destroying static objects and closing files) before returning the status code to the operating system, ensuring resources are properly released.

Explicit std::exit() calls can be made from any function, immediately terminating the program with the provided status code. However, this bypasses destruction of local variables in the calling stack.

Local variable cleanup doesn't occur when std::exit() is called explicitly—only static objects get destroyed, potentially causing resource leaks if objects rely on their destructors for cleanup.

std::atexit() registers cleanup functions that execute automatically when the program terminates normally, whether through main() returning or std::exit() being called. This ensures critical cleanup happens without manual function calls before every exit point.

Abnormal termination via std::abort() immediately ends the program without any cleanup, indicating the program encountered an unrecoverable error. It's used for critical failures that make continuing impossible.

std::terminate() typically calls std::abort() and is primarily used when exceptions aren't handled, providing a last-resort termination mechanism for exceptional circumstances.

When to use halts is almost never—they skip local object destruction, which is crucial in C++. Exceptions provide better error handling, and returning from main() ensures proper cleanup.

Halts exist primarily for legacy code and extreme circumstances. Modern C++ programs should return from main() normally or use exceptions for error conditions, ensuring all objects are properly destroyed and resources are released.