21 Language support library [language.support]

21.5 Start and termination [support.start.term]

1
#
[ Note
:
The header <cstdlib> ([cstdlib.syn]) declares the functions described in this subclause.
— end note
 ]
🔗
[[noreturn]] void _Exit(int status) noexcept;
2
#
Effects: This function has the semantics specified in the C standard library.
3
#
Remarks: The program is terminated without executing destructors for objects of automatic, thread, or static storage duration and without calling functions passed to atexit() ([basic.start.term]).
The function _­Exit is signal-safe ([csignal.syn]).
🔗
[[noreturn]] void abort() noexcept;
4
#
Effects: This function has the semantics specified in the C standard library.
5
#
Remarks: The program is terminated without executing destructors for objects of automatic, thread, or static storage duration and without calling functions passed to atexit() ([basic.start.term]).
The function abort is signal-safe ([csignal.syn]).
🔗
int atexit(c-atexit-handler* f) noexcept; int atexit(atexit-handler* f) noexcept;
6
#
Effects: The atexit() functions register the function pointed to by f to be called without arguments at normal program termination.
It is unspecified whether a call to atexit() that does not happen before ([intro.multithread]) a call to exit() will succeed.
[ Note
:
The atexit() functions do not introduce a data race ([res.on.data.races]).
— end note
 ]
7
#
Implementation limits: The implementation shall support the registration of at least 32 functions.
8
#
Returns: The atexit() function returns zero if the registration succeeds, nonzero if it fails.
🔗
[[noreturn]] void exit(int status);
9
#
Effects:
  • (9.1)
    First, objects with thread storage duration and associated with the current thread are destroyed.
    Next, objects with static storage duration are destroyed and functions registered by calling atexit are called.215
    See [basic.start.term] for the order of destructions and calls.
    (Automatic objects are not destroyed as a result of calling exit().)216
    If control leaves a registered function called by exit because the function does not provide a handler for a thrown exception, std​::​terminate() shall be called ([except.terminate]).
  • (9.2)
    Next, all open C streams (as mediated by the function signatures declared in <cstdio>) with unwritten buffered data are flushed, all open C streams are closed, and all files created by calling tmpfile() are removed.
  • (9.3)
    Finally, control is returned to the host environment.
    If status is zero or EXIT_­SUCCESS, an implementation-defined form of the status successful termination is returned.
    If status is EXIT_­FAILURE, an implementation-defined form of the status unsuccessful termination is returned.
    Otherwise the status returned is implementation-defined.217
🔗
int at_quick_exit(c-atexit-handler* f) noexcept; int at_quick_exit(atexit-handler* f) noexcept;
10
#
Effects: The at_­quick_­exit() functions register the function pointed to by f to be called without arguments when quick_­exit is called.
It is unspecified whether a call to at_­quick_­exit() that does not happen before ([intro.multithread]) all calls to quick_­exit will succeed.
[ Note
:
The at_­quick_­exit() functions do not introduce a data race ([res.on.data.races]).
— end note
 ]
[ Note
:
The order of registration may be indeterminate if at_­quick_­exit was called from more than one thread.
— end note
 ]
[ Note
:
The at_­quick_­exit registrations are distinct from the atexit registrations, and applications may need to call both registration functions with the same argument.
— end note
 ]
11
#
Implementation limits: The implementation shall support the registration of at least 32 functions.
12
#
Returns: Zero if the registration succeeds, nonzero if it fails.
🔗
[[noreturn]] void quick_exit(int status) noexcept;
13
#
Effects: Functions registered by calls to at_­quick_­exit are called in the reverse order of their registration, except that a function shall be called after any previously registered functions that had already been called at the time it was registered.
Objects shall not be destroyed as a result of calling quick_­exit.
If control leaves a registered function called by quick_­exit because the function does not provide a handler for a thrown exception, std​::​terminate() shall be called.
[ Note
:
A function registered via at_­quick_­exit is invoked by the thread that calls quick_­exit, which can be a different thread than the one that registered it, so registered functions should not rely on the identity of objects with thread storage duration.
— end note
 ]
After calling registered functions, quick_­exit shall call _­Exit(status).
[ Note
:
The standard file buffers are not flushed.
— end note
 ]
14
#
Remarks: The function quick_­exit is signal-safe ([csignal.syn]) when the functions registered with at_­quick_­exit are.
See also: [basic.start], [basic.start.term], ISO C 7.22.4.
215)
A function is called for every time it is registered.
216)
Objects with automatic storage duration are all destroyed in a program whose main function ([basic.start.main]) contains no automatic objects and executes the call to exit().
Control can be transferred directly to such a main function by throwing an exception that is caught in main.
217)
The macros EXIT_­FAILURE and EXIT_­SUCCESS are defined in <cstdlib>.