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. 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) | (until C++11) |
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 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 | (since C++11) |
atexit
or any destructor of static/thread-local object throws an exception, std::terminate
is called std::tmpfile
are removedexit_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.
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 |
(none).
#include <iostream> #include <cstdlib> class Static { public: ~Static() { std::cout << "Static dtor\n"; } }; class Local { public: ~Local() { std::cout << "Local dtor\n"; } }; Static static_variable; // dtor of this object *will* be called void atexit_handler() { std::cout << "atexit handler\n"; } int main() { Local local_variable; // dtor 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); }
Output:
test atexit handler Static dtor
causes abnormal program termination (without cleaning up) (function) |
|
registers a function to be called on std::exit() invocation (function) |
|
(C++11) | causes quick program termination without completely cleaning up (function) |
(C++11) | registers a function to be called on quick_exit invocation (function) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/utility/program/exit