Difference between revisions of "cpp/utility/program/atexit"
m (Minor tweak.) |
Andreas Krug (Talk | contribs) m (., fmt) |
||
| Line 18: | Line 18: | ||
Registers the function pointed to by {{c|func}} to be called on normal program termination (via {{lc|std::exit()}} or returning from the [[cpp/language/main function|main function]]) | Registers the function pointed to by {{c|func}} to be called on normal program termination (via {{lc|std::exit()}} or returning from the [[cpp/language/main function|main function]]) | ||
{{rrev multi|until1=c++11|rev1= | {{rrev multi|until1=c++11|rev1= | ||
| − | The functions will be called during the destruction of the static objects, in reverse order: if A was registered before B, then the call to B is made before the call to A. Same applies to the ordering between static object constructors and the calls to {{tt|atexit}}: see {{lc|std::exit}}|rev2= | + | The functions will be called during the destruction of the static objects, in reverse order: if A was registered before B, then the call to B is made before the call to A. Same applies to the ordering between static object constructors and the calls to {{tt|atexit}}: see {{lc|std::exit}}.|rev2= |
| − | The functions may be called concurrently with the destruction of the objects with static storage duration and with each other, maintaining the guarantee that if registration of A was sequenced-before the registration of B, then the call to B is sequenced-before the call to A, same applies to the sequencing between static object constructors and calls to {{tt|atexit}}: see {{lc|std::exit}} | + | The functions may be called concurrently with the destruction of the objects with static storage duration and with each other, maintaining the guarantee that if registration of A was sequenced-before the registration of B, then the call to B is sequenced-before the call to A, same applies to the sequencing between static object constructors and calls to {{tt|atexit}}: see {{lc|std::exit}}. |
}} | }} | ||
| Line 62: | Line 62: | ||
const int result_2 = std::atexit(atexit_handler_2); | const int result_2 = std::atexit(atexit_handler_2); | ||
| − | if (result_1 | + | if (result_1 {{!!}} result_2) |
{ | { | ||
std::cerr << "Registration failed!\n"; | std::cerr << "Registration failed!\n"; | ||
Latest revision as of 21:54, 25 October 2023
| Defined in header <cstdlib>
|
||
| (1) | ||
int atexit( /* c-atexit-handler */* func ); int atexit( /* atexit-handler */* func ); |
(until C++11) | |
| int atexit( /* c-atexit-handler */* func ) noexcept; int atexit( /* atexit-handler */* func ) noexcept; |
(since C++11) | |
| extern "C" using /* c-atexit-handler */ = void(); extern "C++" using /* atexit-handler */ = void(); |
(2) | (exposition only*) |
Registers the function pointed to by func to be called on normal program termination (via std::exit() or returning from the main function)
|
The functions will be called during the destruction of the static objects, in reverse order: if A was registered before B, then the call to B is made before the call to A. Same applies to the ordering between static object constructors and the calls to |
(until C++11) |
|
The functions may be called concurrently with the destruction of the objects with static storage duration and with each other, maintaining the guarantee that if registration of A was sequenced-before the registration of B, then the call to B is sequenced-before the call to A, same applies to the sequencing between static object constructors and calls to |
(since C++11) |
The same function may be registered more than once.
If a function exits via an exception, std::terminate is called.
atexit is thread-safe: calling the function from several threads does not induce a data race.
The implementation is guaranteed to support the registration of at least 32 functions. The exact limit is implementation-defined.
Contents |
[edit] Parameters
| func | - | pointer to a function to be called on normal program termination |
[edit] Return value
0 if the registration succeeds, nonzero value otherwise.
[edit] Notes
The two overloads are distinct because the types of the parameter func are distinct (language linkage is part of its type).
[edit] Example
#include <cstdlib> #include <iostream> void atexit_handler_1() { std::cout << "At exit #1\n"; } void atexit_handler_2() { std::cout << "At exit #2\n"; } int main() { const int result_1 = std::atexit(atexit_handler_1); const int result_2 = std::atexit(atexit_handler_2); if (result_1 || result_2) { std::cerr << "Registration failed!\n"; return EXIT_FAILURE; } std::cout << "Returning from main...\n"; return EXIT_SUCCESS; }
Output:
Returning from main... At exit #2 At exit #1
[edit] See also
| causes abnormal program termination (without cleaning up) (function) | |
| causes normal program termination with cleaning up (function) | |
| (C++11) |
causes quick program termination without completely cleaning up (function) |
| (C++11) |
registers a function to be called on std::quick_exit invocation (function) |
| C documentation for atexit
| |
