std::exit (3) - Linux Manuals
Defined in header <cstdlib>
void exit( int exit_code ); (until C++11)
[[noreturn]] void exit( int exit_code ); (since C++11)
Causes normal program termination to occur.
Several cleanup steps are performed:
1) destructors of objects with static storage duration are called in reverse order of completion of their constructors or the completion of their dynamic_initialization, and the functions passed to std::atexit are called in reverse order they are registered (last one first).
a) any static objects whose initialization was completed before the call to std::atexit for some function F will be destroyed after the call to F during program termination. (until C++11)
b) any static objects whose construction began after the call to std::atexit for some function F will be destroyed before the call to F during program termination (this includes the case where std::atexit was called from the constructor of the static object)
1) The destructors of objects with thread local storage_duration that are associated with the current thread, the destructors of objects with static storage duration, and the functions registered with std::atexit are executed concurrently, while maintaining the following guarantees:
a) The last destructor for thread-local objects is sequenced-before the first destructor for a static object
b) If the completion of the constructor or dynamic_initialization for thread-local or static object A was sequenced-before thread-local or static object B, the completion of the destruction of B is sequenced-before the start of the destruction of A (since C++11)
c) If the completion of the initialization of a static object A was sequenced-before the call to std::atexit for some function F, the call to F during termination is sequenced-before the start of the destruction of A
d) If the call to std::atexit for some function F was sequenced-before the completion of initialization of a static object A, the start of the destruction of A is sequenced-before the call to F during termination.
e) If a call to std::atexit for some function F1 was sequenced-before the call to std::atexit for some function F2, then the call to F2 during termination is sequenced-before the call to F1
2) all C streams are flushed and closed
3) files created by std::tmpfile are removed
4) control is returned to the host environment. If exit_code is 0 or EXIT_SUCCESS, an implementation-defined status indicating successful termination is returned. If exit_code is EXIT_FAILURE, an implementation-defined status indicating unsuccessful termination is returned. In other cases implementation-defined status value is returned.
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.
exit_code - exit status of the program
// Run this code
quick_exit causes quick program termination without completely cleaning up
at_quick_exit registers a function to be called on quick_exit invocation