std::basic_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

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica(C++20) Servicios del programa Apoyo de corrutinas(C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías 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)

Servicios generales Objetos función Manipulación de bits(C++20) bitset hash (C++11) Operadores relacionales(en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros 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) Intercambio y operaciones de tipos 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) Tipos vocabulario comunes 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)

 

std::basic_stacktrace

Funciones miembro

basic_stacktrace::basic_stacktrace (C++23)

basic_stacktrace::~basic_stacktrace (C++23)

basic_stacktrace::operator= (C++23)

basic_stacktrace::current (C++23)

basic_stacktrace::get_allocator (C++23)

Iteradores

basic_stacktrace::beginbasic_stacktrace::cbegin (C++23)(C++23)

basic_stacktrace::endbasic_stacktrace::cend (C++23)(C++23)

basic_stacktrace::rbeginbasic_stacktrace::crbegin (C++23)(C++23)

basic_stacktrace::rendbasic_stacktrace::crend (C++23)(C++23)

Capacidad

basic_stacktrace::empty (C++23)

basic_stacktrace::size (C++23)

basic_stacktrace::max_size (C++23)

Acceso a elementos

basic_stacktrace::operator[] (C++23)

basic_stacktrace::at (C++23)

Modificadores

basic_stacktrace::swap (C++23)

Funciones no miembro

operator== operator<=> (C++23)(C++23)

std::swap (C++23)

to_string (C++23)

operator<< (C++23)

Clases auxiliares

hash<basic_stacktrace> (C++23)

 

Definido en el archivo de encabezado <stacktrace>
template<class Allocator > class basic_stacktrace;	(1)	(desde C++23)
using stacktrace =     std::basic_stacktrace<std::allocator<std::stacktrace_entry>>;	(2)	(desde C++23)

1) La plantilla de clase basic_stacktrace representa una instantánea de todo el listado de pila o su parte dada. Satisface los requerimientos de AllocatorAwareContainer, SequenceContainer, y ReversibleContainer, excepto que solo se soportan el movimiento, la asignación, el intercambio, y las operaciones para contenedores de secuencia calificados const, y la semántica de las funciones de comparación es distinta de aquella requerida por un contenedor.

2) Alias de tipo conveniente para el listado de pila, basic_stacktrace, usando el asignador de memoria por defecto, std::allocator.

La secuencia de invocación de la evaluación actual \(\small{ {x}_{0} }\)x₀ en el hilo de ejecución actual es una secuencia \(\small{ ({x}_{0}, \dots, {x}_{n})}\)(x₀, ..., x_n) de evaluaciones tales que, para \(\small{i \ge 0}\)i≥0, \(\small{ {x}_{i} }\)x_i está dentro de la invocación de función \(\small{ {x}_{i+1} }\)x_i+1.

Un listado de pila es una representación aproximada de una secuencia de invocación y consiste en entradas de listado de pila.

Una entrada de listado de pila representa una evaluación en un listado de pila. Se representa por std::stacktrace_entry en la biblioteca estándar de C++.

Parámetros de plantilla

Allocator

-

Un asignador de memoria que se usa para adquirir/liberar memoria y para construir/destruir los elementos en esa memoria. El tipo debe cumplir con los requerimientos de Allocator. El programa está mal formado si Allocator::value_type no es std::stacktrace_entry.

Tipos miembro

Tipo miembro	Definición
value_type(C++23)	std::stacktrace_entry
const_reference(C++23)	const value_type&
reference(C++23)	value_type&
const_iterator(C++23)	Tipo const RandomAccessIterator definido por la implementación que modela a 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)	Tipo entero con signo definido por la implementación.
size_type(C++23)	Tipo entero sin signo definido por la implementación.
allocator_type(C++23)	Allocator (asignador de memoria).

Funciones miembro

(constructor) (C++23)	Crea un nuevo objeto basic_stacktrace (función miembro pública)
(destructor) (C++23)	Destruye el objeto basic_stacktrace. (función miembro pública)
operator= (C++23)	Asigna al objeto basic_stacktrace (función miembro pública)
current [estático](C++23)	Obtiene el listado de pila actual o su parte dada (función miembro estática pública)
get_allocator (C++23)	Devuelve el asignador de memoria asociado. (función miembro pública)
Iteradores
begincbegin (C++23)	Devuelve un iterador al comienzo. (función miembro pública)
endcend (C++23)	Devuelve un iterador al final. (función miembro pública)
rbegincrbegin (C++23)	Devuelve un iterador inverso al comienzo. (función miembro pública)
rendcrend (C++23)	Devuelve un iterador inverso al final. (función miembro pública)
Capacidad
empty (C++23)	Comprueba si el objeto basic_stacktrace está vacío. (función miembro pública)
size (C++23)	Devuelve el número de entradas de listado de pila. (función miembro pública)
max_size (C++23)	Devuelve el número máximo posible de entradas de listado de pila. (función miembro pública)
Acceso a elementos
operator[] (C++23)	Accede a una entrada de listado de pila especificada. (función miembro pública)
at (C++23)	Accede a la entrada de listado de pila especificada con comprobación de límites. (función miembro pública)
Modificadores
swap (C++23)	Intercambia el contenido. (función miembro pública)

Funciones no miembro

operator==operator<=> (C++23)	Compara los tamaños y el contenido de dos valores basic_stacktrace. (plantilla de función)
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 listado de pila, basic_stacktrace (plantilla de función)
operator<< (C++23)	Ejecuta salida de flujo del listado de pila, basic_stracktrace (plantilla de función)

Clases auxiliares

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)

Notas

Se proporciona el soporte de asignadores de memoria personalizados para usar a basic_stacktrace en una ruta de acceso activa o en ambientes embebidos. Los usuarios pueden asignar memoria de objetos stacktrace_entry en la pila o en algún otro lugar, si es apropriado.

Véase también

stacktrace_entry (C++23)

Representación de una evaluación en un listado de pila (clase)