Language | ||||
Standard Library Headers | ||||
Freestanding and hosted implementations | ||||
Named requirements | ||||
Language support library | ||||
Concepts library(C++20) | ||||
Diagnostics library | ||||
Utilities library | ||||
Strings library | ||||
Containers library | ||||
Iterators library | ||||
Ranges library(C++20) | ||||
Algorithms library | ||||
Numerics library | ||||
Input/output library | ||||
Localizations library | ||||
Regular expressions library(C++11) | ||||
Atomic operations library(C++11) | ||||
Thread support library(C++11) | ||||
Filesystem library(C++17) | ||||
Technical Specifications |
Type support (basic types, RTTI, type traits) | |||||||||||||||
Dynamic memory management | |||||||||||||||
Error handling | |||||||||||||||
Program utilities | |||||||||||||||
Variadic functions | |||||||||||||||
Library feature-test macros | |||||||||||||||
Date and time | |||||||||||||||
Function objects | |||||||||||||||
Formatting library(C++20) | |||||||||||||||
(C++11) | |||||||||||||||
(C++20) | |||||||||||||||
(C++11) | |||||||||||||||
(C++14) | |||||||||||||||
Relational operators (deprecated in C++20) | |||||||||||||||
Comparisons (C++20) | |||||||||||||||
Integer comparison functions | |||||||||||||||
(C++20) | |||||||||||||||
Common vocabulary types | |||||||||||||||
| |||||||||||||||
Swap, forward and move | |||||||||||||||
(C++14) | |||||||||||||||
(C++11) | |||||||||||||||
(C++11) | |||||||||||||||
(C++11) | |||||||||||||||
Elementary string conversions | |||||||||||||||
(C++17) | |||||||||||||||
(C++17) | |||||||||||||||
(C++17) | |||||||||||||||
Type operations | |||||||||||||||
(C++11) | |||||||||||||||
(C++17) | |||||||||||||||
(C++17) |
Program termination | |||||
| |||||
Communicating with the environment | |||||
Signals | |||||
Signal types | |||||
Non-local jumps | |||||
Types |
Defined in header <cstdlib> | |
(until C++11) | |
[[noreturn]]void exit(int exit_code ); | (since C++11) |
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 calledexit_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.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 |
causes abnormal program termination (without cleaning up) (function)[edit] | |
registers a function to be called on std::exit() invocation (function)[edit] | |
(C++11) | causes quick program termination without completely cleaning up (function)[edit] |
(C++11) | registers a function to be called on quick_exit invocation (function)[edit] |
main
.exit
is returned to the operating system as the program's return code or exit code. By convention, a return code of zero means that the program completed successfully. You can use the constants EXIT_FAILURE and EXIT_SUCCESS, also defined in <stdlib.h>, to indicate success or failure of your program.main
function is equivalent to calling the exit
function with the return value as its argument.exit
and abort
is that exit
allows the C++ run-time termination processing to take place (global object destructors will be called), whereas abort
terminates the program immediately. The abort
function bypasses the normal destruction process for initialized global static objects. It also bypasses any special processing that was specified using the atexit function.main
is functionally equivalent to calling the exit
function. Consider the following example:exit
and return statements in the preceding example are functionally identical. However, C++ requires that functions that have return types other than void return a value. The return statement allows you to return a value from main
.exit
or execute a return statement from main
, static objects are destroyed in the reverse order of their initialization (after the call to atexit
Your first c++ dev-c++. if one exists). The following example shows how such initialization and cleanup works.sd1
and sd2
are created and initialized before entry to main
. After this program terminates using the return statement, first sd2
is destroyed and then sd1
. The destructor for the ShowData
class closes the files associated with these static objects.ShowData
objects with block scope, allowing them to be destroyed when they go out of scope: Uso de getch en dev c++.