Archivo de encabezado de la biblioteca estándar <stacktrace>

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Archivos de encabezado de la biblioteca estándar

Apoyo del lenguaje <cfloat> <climits> <compare>(C++20) <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) Conceptos <concepts>(C++20) Diagnósticos <cassert> <cerrno> <debugging>(C++26) <stacktrace>(C++23) <stdexcept> <system_error>(C++11) Gestión de memoria <memory> <memory_resource>(C++17) <scoped_allocator>(C++11) Metaprogramación <type_traits>(C++11) <ratio>(C++11)

Servicios generales <any>(C++17) <bitset> <bit>(C++20) <charconv>(C++17) <expected>(C++23) <format>(C++20) <functional> <optional>(C++17) <tuple>(C++11) <typeindex>(C++11) <utility> <variant>(C++17) Contenedores <array>(C++11) <deque> <flat_map>(C++23) <flat_set>(C++23) <forward_list>(C++11) <inplace_vector>(C++26)    <list> <map> <mdspan>(C++23) <queue> <set> <span>(C++20) <stack> <unordered_map>(C++11) <unordered_set>(C++11) <vector> Iteradores <iterator> Rangos <generator>(C++23) <ranges>(C++20)

Algoritmos <algorithm> <numeric> Cadenas <cctype> <cstring> <cuchar>(C++11) <cwchar> <cwctype> <string_view>(C++17) <string> Procesamiento de texto <clocale> <codecvt>(C++11/17/26*) <locale> <regex>(C++11) <text_encoding>(C++26)    Numéricos <cfenv>(C++11) <cmath> <complex> <linalg>(C++26) <numbers>(C++20) <random>(C++11) <simd>(C++26) <valarray> Tiempo <chrono>(C++11) <ctime> Compatibilidad con C <ccomplex>(C++11/17/20*) <ciso646>(hasta C++20) <cstdalign>(C++11/17/20*) <cstdbool>(C++11/17/20*) <ctgmath>(C++11/17/20*)

Entrada/Salida <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) Apoyo para concurrencia <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) Apoyo de ejecución <execution>(C++17)

 

Este archivo de encabezado es parte de la biblioteca de utilerías generales.

Clases
stacktrace_entry (C++23)	Representación de una evaluación en un listado de pila (clase)
basic_stacktrace (C++23)	Una representación aproximada de una secuencia de invocación que consiste de entradas de listado de pila. (plantilla de clase)
std::hash<std::stacktrace_entry> (C++23)	Soporte de hash (resumen) para std::stacktrace_entry (especialización de plantilla de clase)
std::hash<std::basic_stacktrace> (C++23)	Soporte para hash (resumen) para el listado de pila, std::basic_stacktrace (especialización de plantilla de clase)
Declaraciones adelantadas
Definido en el archivo de encabezado <functional>
hash (C++11)	Objeto función de dispersión (hash). (plantilla de clase)
Funciones
std::swap(std::basic_stacktrace) (C++23)	Especializa el algoritmo std::swap (plantilla de función)
to_string (C++23)	Devuelve una cadena con una descripción del objeto stacktrace_entry (función)
to_string (C++23)	Devuelve una cadena con una descripción del listado de pila, basic_stacktrace (plantilla de función)
operator<< (C++23)	Ejecuta salida de flujo del objeto stacktrace_entry (plantilla de función)
operator<< (C++23)	Ejecuta salida de flujo del listado de pila, basic_stracktrace (plantilla de función)

Sinopsis

namespace std {// clase stacktrace_entryclass stacktrace_entry;   // plantilla de clase basic_stacktracetemplate<class Allocator>class basic_stacktrace;   // nombres de definiciones de tipo de basic_stacktraceusing stacktrace = basic_stacktrace<allocator<stacktrace_entry>>;   // funciones no miembrotemplate<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);   template<class CharT, class traits> basic_ostream<CharT, traits>& operator<<(basic_ostream<CharT, traits>& os, const stacktrace_entry& f);   template<class CharT, class Traits, class Allocator> basic_ostream<CharT, traits>& operator<<(basic_ostream<CharT, Traits>& os, const basic_stacktrace<Allocator>& st);   // soporte para hash (resumen)template<class T>struct hash;template<>struct hash<stacktrace_entry>;template<class Allocator>struct hash<basic_stacktrace<Allocator>>;}

Clase std::stacktrace_entry

namespace std {class stacktrace_entry {public:using native_handle_type =/* definido por la implementación */;   // constructoresconstexpr stacktrace_entry()noexcept;constexpr stacktrace_entry(const stacktrace_entry& other)noexcept;constexpr stacktrace_entry& operator=(const stacktrace_entry& other)noexcept;   ~stacktrace_entry();   // observadoresconstexpr native_handle_type native_handle()constnoexcept;constexprexplicit operator bool()constnoexcept;   // consulta string description()const; string source_file()const; uint_least32_t source_line()const;   // comparaciónfriendconstexprbool operator==(const stacktrace_entry& x, const stacktrace_entry& y)noexcept;friendconstexpr strong_ordering operator<=>(const stacktrace_entry& x, const stacktrace_entry& y)noexcept;};}

Plantilla de clase 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 =/* definido por la implementación */;using iterator = const_iterator;using reverse_iterator =std::reverse_iterator<iterator>;using const_reverse_iterator =std::reverse_iterator<const_iterator>;using difference_type =/* definido por la implementación */;using size_type =/* definido por la implementación */;using allocator_type = Allocator;   // creación y asignaciónstatic 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();   // observadores 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;   [[nodiscard]]bool empty()constnoexcept; size_type size()constnoexcept; size_type max_size()constnoexcept;   const_reference operator[](size_type)const; const_reference at(size_type)const;   // comparacionestemplate<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;   // modificadoresvoid 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_;// solo exposición};}