std::atexit

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Programm-Support-Dienstprogramme

Programmabbruch
abort exit quick_exit (C++11) _Exit (C++11)	atexit at_quick_exit (C++11) EXIT_SUCCESSEXIT_FAILURE
Unerreichbarer Kontrollfluss
unreachable (C++23)
Kommunikation mit der Umgebung
system	getenv
Signale
signal raise sig_atomic_t	SIG_DFLSIG_IGN SIG_ERR
Signalarten
SIGABRTSIGFPESIGILL	SIGINTSIGSEGVSIGTERM
Nicht-lokale Sprünge
setjmp	longjmp
Typen
jmp_buf

 

Definiert in Header <cstdlib>
	(1)
int atexit( /* c-atexit-handler */* func ); int atexit( /* atexit-handler */* func );			(bis C++11)
int atexit( /* c-atexit-handler */* func ) noexcept; int atexit( /* atexit-handler */* func ) noexcept;			(seit C++11)
extern "C" using /* c-atexit-handler */ = void(); extern "C++" using /* atexit-handler */ = void();		(2)	(nur Exposition*)

Registriert die durch func gezeigte Funktion, damit sie bei normaler Programmbeendigung (durch std::exit() oder Rückkehr aus der main-Funktion) aufgerufen wird.

Die Funktionen werden während der Zerstörung der statischen Objekte in umgekehrter Reihenfolge aufgerufen: Wenn A vor B registriert wurde, dann wird B vor A aufgerufen. Dasselbe gilt für die Reihenfolge zwischen Konstruktoren statischer Objekte und den Aufrufen von atexit: siehe std::exit.

(bis C++11)

Die Funktionen können gleichzeitig mit der Zerstörung der Objekte mit statischer Speicherdauer und untereinander aufgerufen werden, wobei die Garantie aufrechterhalten wird, dass wenn die Registrierung von A vor der Registrierung von B erfolgte, der Aufruf von B vor dem Aufruf von A erfolgt. Dasselbe gilt für die Sequenzierung zwischen Konstruktoren statischer Objekte und Aufrufen von atexit: siehe std::exit.

(seit C++11)

Dieselbe Funktion kann mehrfach registriert werden.

Wenn eine Funktion eine Ausnahme auslöst, wird std::terminate aufgerufen.

atexit ist Thread-sicher: Das Aufrufen der Funktion aus mehreren Threads verursacht keine Datenrace-Bedingung.

Die Implementierung garantiert die Unterstützung der Registrierung von mindestens 32 Funktionen. Die genaue Grenze ist implementierungsabhängig.

Parameter

func

-

Zeiger auf eine Funktion, die bei normaler Programmbeendigung aufgerufen werden soll

Rückgabewert

​0​, wenn die Registrierung erfolgreich ist, ein von Null verschiedener Wert andernfalls.

Hinweise

Die beiden Überladungen sind verschieden, da die Typen des Parameters func unterschiedlich sind (Sprachverknüpfung ist Teil seines Typs).

Beispiel

Führen Sie diesen Code aus

#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;
}

Ausgabe

Returning from main...
At exit #2
At exit #1

Siehe auch

abort	verursacht abnormalen Programmabbruch (ohne Bereinigung) (funktion)
exit	verursacht normalen Programmabbruch mit Bereinigung (funktion)
quick_exit (C++11)	verursacht schnellen Programmabbruch ohne vollständige Bereinigung (funktion)
at_quick_exit (C++11)	registriert eine Funktion, die bei Aufruf von std::quick_exit aufgerufen wird (funktion)
C-Dokumentation für atexit