std::basic_stacktrace

 

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

 

Diagnostik-Bibliothek

Ausnahmebehandlung exception uncaught_exceptionuncaught_exceptions (bis C++20*)  (C++17) exception_ptr (C++11) make_exception_ptr (C++11) current_exception (C++11) rethrow_exception (C++11) nested_exception (C++11) throw_with_nested (C++11) rethrow_if_nested (C++11) Exception handling failures terminate terminate_handler get_terminate (C++11) set_terminate bad_exception unexpected (bis C++17*) unexpected_handler (bis C++17*) get_unexpected (bis C++17*) set_unexpected (bis C++17*) Fehlernummern Error codes errno Assertions assert

Exception categories logic_error invalid_argument domain_error length_error out_of_range runtime_error range_error overflow_error underflow_error tx_exception (TM TS) System error error_category (C++11) generic_category (C++11) system_category (C++11) error_condition (C++11) errc (C++11) error_code (C++11) system_error (C++11) Stacktrace stacktrace_entry (C++23) basic_stacktrace (C++23) Debugging-Unterstützung is_debugger_present (C++26) breakpoint_if_debugging (C++26) breakpoint (C++26)

 

std::basic_stacktrace

Memberfunktionen

basic_stacktrace::basic_stacktrace

basic_stacktrace::~basic_stacktrace

basic_stacktrace::operator=

basic_stacktrace::current

basic_stacktrace::get_allocator

Iteratoren

basic_stacktrace::beginbasic_stacktrace::cbegin

basic_stacktrace::endbasic_stacktrace::cend

basic_stacktrace::rbeginbasic_stacktrace::crbegin

basic_stacktrace::rendbasic_stacktrace::crend

Kapazität

basic_stacktrace::empty

basic_stacktrace::size

basic_stacktrace::max_size

Elementzugriff

basic_stacktrace::operator[]

basic_stacktrace::at

Modifizierer

basic_stacktrace::swap

Nicht-Member-Funktionen

operator== operator<=>

swap(std::basic_stacktrace)

to_string(std::basic_stacktrace)

operator<<

Hilfsklassen

hash<std::basic_stacktrace>

formatter<std::basic_stacktrace>

 

Definiert in der Header-Datei <stacktrace>
template< class Allocator > class basic_stacktrace;	(1)	(seit C++23)
using stacktrace =     std::basic_stacktrace<std::allocator<std::stacktrace_entry>>;	(2)	(seit C++23)
namespace pmr { using stacktrace =     std::basic_stacktrace<std::pmr::polymorphic_allocator<std::stacktrace_entry>>; }	(3)	(seit C++23)

1) Die Klasse basic_stacktrace repräsentiert einen Schnappschuss des gesamten Stacktrace oder eines gegebenen Teils davon. Sie erfüllt die Anforderungen von AllocatorAwareContainer, SequenceContainer und ReversibleContainer, mit der Ausnahme, dass nur Move-, Zuweisungs- und Swap-Operationen sowie Operationen für const-qualifizierte Sequenzcontainer unterstützt werden und die Semantik der Vergleichsfunktionen von der für Container erforderlichen abweicht.

2) Bequeme Typalias für basic_stacktrace unter Verwendung des Standard-std::allocator.

3) Bequeme Typalias für basic_stacktrace unter Verwendung des polymorphen Allocator.

Die *Aufrufsequenz* der aktuellen Auswertung \(\small{ {x}_{0} }\)x₀ im aktuellen Ausführungsthread ist eine Sequenz \(\small{ ({x}_{0}, \dots, {x}_{n})}\)(x₀, ..., x_n) von Auswertungen, sodass für \(\small{i \ge 0}\)i≥0 \(\small{ {x}_{i} }\)x_i innerhalb des Funktionsaufrufs \(\small{ {x}_{i+1} }\)x_i+1 liegt.

Ein *Stacktrace* ist eine ungefähre Darstellung einer Aufrufsequenz und besteht aus Stacktrace-Einträgen.

Ein *Stacktrace-Eintrag* repräsentiert eine Auswertung in einem Stacktrace. Er wird in der C++-Standardbibliothek durch std::stacktrace_entry dargestellt.

Template-Parameter

Allocator

-

Ein Allocator, der zum Erwerben/Freigeben von Speicher und zum Erstellen/Zerstören der Elemente in diesem Speicher verwendet wird. Der Typ muss die Anforderungen von Allocator erfüllen. Das Programm ist ill-formed, wenn Allocator::value_type nicht std::stacktrace_entry ist.

Mitgliedertypen

Mitgliedertyp	Definition
value_type	std::stacktrace_entry
const_reference	const value_type&
Referenz	value_type&
const_iterator	Implementierungsabhängiger const LegacyRandomAccessIterator-Typ, der random_access_iterator modelliert
iterator	const_iterator
reverse_iterator	std::reverse_iterator<iterator>
reverse_const_iterator	std::reverse_iterator<const_iterator>
difference_type	Implementierungsabhängiger vorzeichenbehafteter Ganzzahltyp
size_type	Implementierungsabhängiger vorzeichenloser Ganzzahltyp
allocator_type	Allocator

Member-Funktionen

(Konstruktor)	erstellt einen neuen basic_stacktrace (public member function)
(Destruktor)	zerstört den basic_stacktrace (public member function)
operator=	weist einem basic_stacktrace zu (public member function)
current [static]	holt den aktuellen Stacktrace oder dessen gegebenen Teil (public static member function)
get_allocator	gibt den zugehörigen Allocator zurück (public member function)
Iteratoren
begincbegin	gibt einen Iterator zum Anfang zurück (public member function)
endcend	gibt einen Iterator zum Ende zurück (public member function)
rbegincrbegin	gibt einen Reverse-Iterator zum Anfang zurück (public member function)
rendcrend	gibt einen Reverse-Iterator zum Ende zurück (public member function)
Kapazität
empty	prüft, ob der basic_stacktrace leer ist (public member function)
size	gibt die Anzahl der Stacktrace-Einträge zurück (public member function)
max_size	gibt die maximal mögliche Anzahl von Stacktrace-Einträgen zurück (public member function)
Elementzugriff
operator[]	greift auf einen bestimmten Stacktrace-Eintrag zu (public member function)
at	greift auf einen bestimmten Stacktrace-Eintrag mit Bereichsprüfung zu (public member function)
Modifizierer
swap	tauscht die Inhalte (public member function)

Nicht-Member-Funktionen

operator==operator<=> (C++23)	vergleicht die Größen und Inhalte zweier basic_stacktrace-Werte (function template)
std::swap(std::basic_stacktrace) (C++23)	spezialisiert den Algorithmus std::swap (function template)
to_string (C++23)	gibt einen String mit einer Beschreibung des basic_stacktrace zurück (function template)
operator<< (C++23)	führt die Stream-Ausgabe von basic_stracktrace durch (function template)

Hilfsklassen

std::hash<std::basic_stacktrace> (C++23)	Hash-Unterstützung für std::basic_stacktrace (class template specialization)
std::formatter<std::basic_stacktrace> (C++23)	Formatierungsunterstützung für basic_stacktrace (class template specialization)

Anmerkungen

Die Unterstützung für benutzerdefinierte Allocators wird bereitgestellt, um basic_stacktrace auf einem Hot Path oder in eingebetteten Umgebungen zu verwenden. Benutzer können stacktrace_entry-Objekte auf dem Stack oder an einem anderen geeigneten Ort allozieren.

Die Sequenz der von einem std::basic_stacktrace gehaltenen std::stacktrace_entry-Objekte ist unveränderlich und entweder leer oder repräsentiert ein zusammenhängendes Intervall des gesamten Stacktrace.

boost::stacktrace::basic_stacktrace (verfügbar in Boost.Stacktrace) kann stattdessen verwendet werden, wenn std::basic_stacktrace nicht verfügbar ist.

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_stacktrace	202011L	(C++23)	Stacktrace-Bibliothek
__cpp_lib_formatters	202302L	(C++23)	Formatierung von std::thread::id und std::stacktrace

Beispiel

Die Ausgabe wurde mit Compiler Explorer erzielt: msvc und gcc.

Führen Sie diesen Code aus

#include <iostream>
#include <stacktrace>
 
int nested_func(int c)
{
    std::cout << std::stacktrace::current() << '\n';
    return c + 1;
}
 
int func(int b)
{
    return nested_func(b + 1);
}
 
int main()
{
    std::cout << func(777);
}

Mögliche Ausgabe

// msvc output (the lines ending with '⤶' arrows are split to fit the width):
0> C:\Users\ContainerAdministrator\AppData\Local\Temp\compiler-explorer-compiler20221122-⤶
31624-2ja1sf.8ytzw\example.cpp(6): output_s!nested_func+0x1F
1> C:\Users\ContainerAdministrator\AppData\Local\Temp\compiler-explorer-compiler20221122-⤶
31624-2ja1sf.8ytzw\example.cpp(12): output_s!func+0x15
2> C:\Users\ContainerAdministrator\AppData\Local\Temp\compiler-explorer-compiler20221122-⤶
31624-2ja1sf.8ytzw\example.cpp(15): output_s!main+0xE
3> D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl(288): output_s!⤶
__scrt_common_main_seh+0x10C
4> KERNEL32!BaseThreadInitThunk+0x14
5> ntdll!RtlUserThreadStart+0x21
779
 
gcc output:
   0# nested_func(int) at /app/example.cpp:7
   1# func(int) at /app/example.cpp:13
   2#      at /app/example.cpp:18
   3#      at :0
   4#      at :0
   5# 
 
779

Siehe auch

stacktrace_entry (C++23)

Repräsentation einer Auswertung in einem Stacktrace (class)