Standard library header <stacktrace> (C++23)

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros(C++20)

Language support library

Concepts library(C++20)

Diagnostics library

Memory management library

Metaprogramming library(C++11)

General utilities library

Containers library

Iterators library

Ranges library(C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library(C++17)

Concurrency support library(C++11)

Execution control library(C++26)

Technical specifications

Symbols index

External libraries

 

Standard library headers

Language support <cfloat> <climits> <compare>(C++20) <contracts>(C++26) <coroutine>(C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint>(C++11) <cstdlib> <exception> <initializer_list>(C++11)    <limits> <new> <source_location>(C++20) <stdfloat>(C++23) <typeinfo> <version>(C++20) Concepts <concepts>(C++20) Diagnostics <cassert> <cerrno> <debugging>(C++26) <stacktrace>(C++23) <stdexcept> <system_error>(C++11) Memory management <memory> <memory_resource>(C++17) <scoped_allocator>(C++11) Metaprogramming <type_traits>(C++11) <ratio>(C++11)

General utilities <any>(C++17) <bitset> <bit>(C++20) <charconv>(C++17) <expected>(C++23) <format>(C++20) <functional> <optional>(C++17) <stdbit.h>(C++26) <tuple>(C++11) <typeindex>(C++11) <utility> <variant>(C++17) Containers <array>(C++11) <deque> <flat_map>(C++23) <flat_set>(C++23) <forward_list>(C++11) <hive>(C++26) <inplace_vector>(C++26)    <list> <map> <mdspan>(C++23) <queue> <set> <span>(C++20) <stack> <unordered_map>(C++11) <unordered_set>(C++11) <vector> Iterators <iterator> Ranges <generator>(C++23) <ranges>(C++20)

Algorithms <algorithm> <numeric> Strings <cctype> <cstring> <cuchar>(C++11) <cwchar> <cwctype> <string_view>(C++17) <string> Text processing <clocale> <codecvt>(C++11/17/26*) <locale> <regex>(C++11) <text_encoding>(C++26)    Numerics <cfenv>(C++11) <cmath> <complex> <linalg>(C++26) <numbers>(C++20) <random>(C++11) <simd>(C++26) <stdckdint.h>(C++26) <valarray> Time <chrono>(C++11) <ctime> C compatibility <ccomplex>(C++11/17/20*) <ciso646>(until C++20) <cstdalign>(C++11/17/20*) <cstdbool>(C++11/17/20*) <ctgmath>(C++11/17/20*)

Input/output <cinttypes>(C++11) <cstdio> <filesystem>(C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print>(C++23) <spanstream>(C++23) <sstream> <streambuf> <strstream>(C++98/26*) <syncstream>(C++20) Concurrency support <atomic>(C++11) <barrier>(C++20) <condition_variable>(C++11) <future>(C++11) <hazard_pointer>(C++26) <latch>(C++20) <mutex>(C++11) <rcu>(C++26) <semaphore>(C++20) <shared_mutex>(C++14) <stdatomic.h>(C++23) <stop_token>(C++20) <thread>(C++11) Execution support <execution>(C++17)

 

This header is part of the diagnostics library.

Classes
stacktrace_entry (C++23)	representation of an evaluation in a stacktrace (class)
basic_stacktrace (C++23)	approximate representation of an invocation sequence consists of stacktrace entries (class template)
std::hash<std::stacktrace_entry> (C++23)	hash support for std::stacktrace_entry (class template specialization)
std::hash<std::basic_stacktrace> (C++23)	hash support for std::basic_stacktrace (class template specialization)
Forward declarations
Defined in header <functional>
hash (C++11)	hash function object (class template)

Type aliases
Alias	Type
std::stacktrace	std::basic_stacktrace<std::allocator<std::stacktrace_entry>>
std::pmr::stacktrace	std::pmr::basic_stacktrace<     std::pmr::polymorphic_allocator<std::stacktrace_entry>>

Functions
std::swap(std::basic_stacktrace) (C++23)	specializes the std::swap algorithm (function template)
to_string (C++23)	returns a string with a description of the stacktrace_entry (function)
to_string (C++23)	returns a string with a description of the basic_stacktrace (function template)
operator<< (C++23)	performs stream output of stacktrace_entry (function template)
operator<< (C++23)	performs stream output of basic_stracktrace (function template)

Synopsis

namespace std {// class stacktrace_entryclass stacktrace_entry;   // class template basic_stacktracetemplate<class Allocator>class basic_stacktrace;   // basic_stacktrace typedef namesusing stacktrace = basic_stacktrace<allocator<stacktrace_entry>>;   // non-member functionstemplate<class Allocator>void swap(basic_stacktrace<Allocator>& a, basic_stacktrace<Allocator>& b)noexcept(noexcept(a.swap(b)));   string to_string(const stacktrace_entry& f);   template<class Allocator> string to_string(const basic_stacktrace<Allocator>& st);   ostream& operator<<(ostream& os, const stacktrace_entry& f);   template<class Allocator> ostream& operator<<(ostream& os, const basic_stacktrace<Allocator>& st);   namespace pmr {using stacktrace =std::basic_stacktrace<polymorphic_allocator<stacktrace_entry>>;}   // hash supporttemplate<class T>struct hash;template<>struct hash<stacktrace_entry>;template<class Allocator>struct hash<basic_stacktrace<Allocator>>;}

Class std::stacktrace_entry

namespace std {class stacktrace_entry {public:using native_handle_type =/* implementation-defined */;   // constructorsconstexpr stacktrace_entry()noexcept;constexpr stacktrace_entry(const stacktrace_entry& other)noexcept;constexpr stacktrace_entry& operator=(const stacktrace_entry& other)noexcept;   ~stacktrace_entry();   // observersconstexpr native_handle_type native_handle()constnoexcept;constexprexplicit operator bool()constnoexcept;   // query string description()const; string source_file()const; uint_least32_t source_line()const;   // comparisonfriendconstexprbool operator==(const stacktrace_entry& x, const stacktrace_entry& y)noexcept;friendconstexpr strong_ordering operator<=>(const stacktrace_entry& x, const stacktrace_entry& y)noexcept;};}

Class template std::basic_stacktrace

namespace std {template<class Allocator>class basic_stacktrace {public:using value_type = stacktrace_entry;using const_reference =const value_type&;using reference = value_type&;using const_iterator =/* implementation-defined */;using iterator = const_iterator;using reverse_iterator =std::reverse_iterator<iterator>;using const_reverse_iterator =std::reverse_iterator<const_iterator>;using difference_type =/* implementation-defined */;using size_type =/* implementation-defined */;using allocator_type = Allocator;   // creation and assignmentstatic basic_stacktrace current(const allocator_type& alloc = allocator_type())noexcept;static basic_stacktrace current(size_type skip, const allocator_type& alloc = allocator_type())noexcept;static basic_stacktrace current(size_type skip, size_type max_depth, const allocator_type& alloc = allocator_type())noexcept;   basic_stacktrace()noexcept(is_nothrow_default_constructible_v<allocator_type>);explicit basic_stacktrace(const allocator_type& alloc)noexcept;   basic_stacktrace(const basic_stacktrace& other); basic_stacktrace(basic_stacktrace&& other)noexcept; basic_stacktrace(const basic_stacktrace& other, const allocator_type& alloc); basic_stacktrace(basic_stacktrace&& other, const allocator_type& alloc); basic_stacktrace& operator=(const basic_stacktrace& other); basic_stacktrace& operator=(basic_stacktrace&& other)noexcept( allocator_traits<Allocator>::propagate_on_container_move_assignment::value|| allocator_traits<Allocator>::is_always_equal::value);   ~basic_stacktrace();   // observers allocator_type get_allocator()constnoexcept;   const_iterator begin()constnoexcept; const_iterator end()constnoexcept; const_reverse_iterator rbegin()constnoexcept; const_reverse_iterator rend()constnoexcept;   const_iterator cbegin()constnoexcept; const_iterator cend()constnoexcept; const_reverse_iterator crbegin()constnoexcept; const_reverse_iterator crend()constnoexcept;   bool empty()constnoexcept; size_type size()constnoexcept; size_type max_size()constnoexcept;   const_reference operator[](size_type)const; const_reference at(size_type)const;   // comparisonstemplate<class Allocator2>friendbool operator==(const basic_stacktrace& x, const basic_stacktrace<Allocator2>& y)noexcept;template<class Allocator2>friend strong_ordering operator<=>(const basic_stacktrace& x, const basic_stacktrace<Allocator2>& y)noexcept;   // modifiersvoid swap(basic_stacktrace& other)noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value|| allocator_traits<Allocator>::is_always_equal::value);   private: vector<value_type, allocator_type> frames_;// exposition only};}