std:: exit

Causes normal program termination to occur.

Several cleanup steps are performed:

• In the above,

• If any function registered with atexit or any destructor of static/thread-local object throws an exception, std::terminate is called.
• If the compiler opted to lift dynamic initialization of an object to the static initialization phase of non-local initialization , the sequencing of destruction honors its would-be dynamic initialization.
• If a function-local (block-scope) static object was destroyed and then that function is called from the destructor of another static object and the control flow passes through the definition of that object (or if it is used indirectly, via pointer or reference), the behavior is undefined.
• If a function-local (block-scope) static object was initialized during construction of a subobject of a class or array, it is only destroyed after all subobjects of that class or all elements of that array were destroyed.

Stack is not unwound: destructors of variables with automatic storage duration are not called.

Relationship with the main function

Returning from the main function , either by a return statement or by reaching the end of the function performs the normal function termination (calls the destructors of the variables with automatic storage durations ) and then executes std::exit , passing the argument of the return statement (or ​ 0 ​ if implicit return was used) as exit_code .

Parameters

Return value

(none)

Example

#include <cstdlib>
#include <iostream>
 
struct Static
{
    ~Static() 
    {
        std::cout << "Static destructor\n";
    }
};
 
struct Local
{
    ~Local() 
    {
        std::cout << "Local destructor\n";
    }
};
 
Static static_variable; // Destructor of this object *will* be called
 
void atexit_handler()
{
    std::cout << "atexit handler\n";
}
 
int main()
{
    Local local_variable; // Destructor of this object will *not* be called
    const int result = std::atexit(atexit_handler); // Handler will be called
 
    if (result != 0)
    {
        std::cerr << "atexit registration failed\n";
        return EXIT_FAILURE;
    }
 
    std::cout << "test\n";
    std::exit(EXIT_FAILURE);
 
    std::cout << "this line will *not* be executed\n";
}

test
atexit handler
Static destructor

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

See also