std::basic_stacktrace
Defined in header <stacktrace> |
||
|---|---|---|
template< class Allocator > class basic_stacktrace; |
(1) | (since C++23) |
using stacktrace =
std::basic_stacktrace<std::allocator<std::stacktrace_entry>>; |
(2) | (since C++23) |
namespace pmr {
using stacktrace =
std::basic_stacktrace<std::pmr::polymorphic_allocator<std::stacktrace_entry>>;
} |
(3) | (since C++23) |
basic_stacktrace class template represents a snapshot of the whole stacktrace or its given part. It satisfies the requirement of
AllocatorAwareContainer,
SequenceContainer, and
ReversibleContainer, except that only move, assignment, swap, and operations for const-qualified sequence containers are supported, and the semantics of comparison functions are different from those required for a container.
The invocation sequence of the current evaluation \(\small{ {x}_{0} }\)x0 in the current thread of execution is a sequence \(\small{ ({x}_{0}, \dots, {x}_{n})}\)(x0, ..., xn) of evaluations such that, for \(\small{i \ge 0}\)i≥0, \(\small{ {x}_{i} }\)xi is within the function invocation \(\small{ {x}_{i+1} }\)xi+1.
A stacktrace is an approximate representation of an invocation sequence and consists of stacktrace entries.
A stacktrace entry represents an evaluation in a stacktrace. It is represented by std::stacktrace_entry in the C++ standard library.
Template parameters
| Allocator | - | An allocator that is used to acquire/release memory and to construct/destroy the elements in that memory. The type must meet the requirements of Allocator. The program is ill-formed if Allocator::value_type is not std::stacktrace_entry. |
Member types
| Member type | Definition |
|---|---|
value_type(C++23) |
std::stacktrace_entry |
const_reference(C++23) |
const value_type& |
reference(C++23) |
value_type& |
const_iterator(C++23) |
implementation-defined const LegacyRandomAccessIterator type that models random_access_iterator |
iterator(C++23) |
const_iterator |
reverse_iterator(C++23) |
std::reverse_iterator<iterator> |
reverse_const_iterator(C++23) |
std::reverse_iterator<const_iterator> |
difference_type(C++23) |
implementation-defined signed integer type |
size_type(C++23) |
implementation-defined unsigned integer type |
allocator_type(C++23) |
Allocator |
Member functions
|
(C++23)
|
creates a new basic_stacktrace (public member function) |
|
(C++23)
|
destroys the basic_stacktrace (public member function) |
|
(C++23)
|
assigns to the basic_stacktrace (public member function) |
|
[static] (C++23)
|
obtains the current stacktrace or its given part (public static member function) |
|
(C++23)
|
returns the associated allocator (public member function) |
Iterators |
|
|
(C++23)
|
returns an iterator to the beginning (public member function) |
|
(C++23)
|
returns an iterator to the end (public member function) |
|
(C++23)
|
returns a reverse iterator to the beginning (public member function) |
|
(C++23)
|
returns a reverse iterator to the end (public member function) |
Capacity |
|
|
(C++23)
|
checks whether the basic_stacktrace is empty (public member function) |
|
(C++23)
|
returns the number of stacktrace entries (public member function) |
|
(C++23)
|
returns the maximum possible number of stacktrace entries (public member function) |
Element access |
|
|
(C++23)
|
access specified stacktrace entry (public member function) |
|
(C++23)
|
access specified stacktrace entry with bounds checking (public member function) |
Modifiers |
|
|
(C++23)
|
swaps the contents (public member function) |
Non-member functions
|
(C++23)
|
compares the sizes and the contents of two basic_stacktrace values (function template) |
|
(C++23)
|
specializes the std::swap algorithm (function template) |
|
(C++23)
|
returns a string with a description of the basic_stacktrace (function template) |
|
(C++23)
|
performs stream output of basic_stracktrace (function template) |
Helper classes
|
(C++23)
|
hash support for std::basic_stacktrace (class template specialization) |
Notes
Support for custom allocators is provided for using basic_stacktrace on a hot path or in embedded environments. Users can allocate stacktrace_entry objects on the stack or in some other place, where appropriate.
The sequence of std::stacktrace_entry objects owned by a std::basic_stacktrace is immutable, and either is empty or represents a contiguous interval of the whole stacktrace.
boost::stacktrace::basic_stacktrace (available in Boost.Stacktrace) can be used instead when std::basic_stacktrace is not available.
Feature testing macro: __cpp_lib_stacktrace.
Example
See also
|
(C++23)
|
representation of an evaluation in a stacktrace (class) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/utility/basic_stacktrace
