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

 

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 administración de memoria dinámica.

Clases
scoped_allocator_adaptor (C++11)	Implementa un asignador multinivel para contenedores multinivel. (plantilla de clase)
Funciones
operator==operator!=	Compara dos instancias de scoped_allocator_adaptor. (función miembro pública de std::scoped_allocator_adaptor)

Sinopsis

namespace std {// plantilla de clase scoped_allocator_adaptortemplate<class OuterAlloc, class... InnerAlloc>class scoped_allocator_adaptor;   // operadores de asignador de alcancetemplate<class OuterA1, class OuterA2, class... InnerAllocs>bool operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a, const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b)noexcept;}

Plantilla de clase std::scoped_allocator_adaptor

namespace std {template<class OuterAlloc, class... InnerAllocs>class scoped_allocator_adaptor :public OuterAlloc {private:using OuterTraits = allocator_traits<OuterAlloc>;// solo exposición scoped_allocator_adaptor<InnerAllocs...> inner;// solo exposición   public:using outer_allocator_type = OuterAlloc;using inner_allocator_type =/* véase descripción */;   using value_type =typename OuterTraits::value_type;using size_type =typename OuterTraits::size_type;using difference_type =typename OuterTraits::difference_type;using pointer =typename OuterTraits::pointer;using const_pointer =typename OuterTraits::const_pointer;using void_pointer =typename OuterTraits::void_pointer;using const_void_pointer =typename OuterTraits::const_void_pointer;   using propagate_on_container_copy_assignment =/* véase descripción */;using propagate_on_container_move_assignment =/* véase descripción */;using propagate_on_container_swap =/* véase descripción */;using is_always_equal =/* véase descripción */;   template<class Tp>struct rebind {using other = scoped_allocator_adaptor< OuterTraits::template rebind_alloc<Tp>, InnerAllocs...>;};   scoped_allocator_adaptor();template<class OuterA2> scoped_allocator_adaptor(OuterA2&& outerAlloc, const InnerAllocs&... innerAllocs)noexcept;   scoped_allocator_adaptor(const scoped_allocator_adaptor& other)noexcept; scoped_allocator_adaptor(scoped_allocator_adaptor&& other)noexcept;   template<class OuterA2> scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& other)noexcept;template<class OuterA2> scoped_allocator_adaptor( scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other)noexcept;   scoped_allocator_adaptor& operator=(const scoped_allocator_adaptor&)=default; scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&)=default;   ~scoped_allocator_adaptor();   inner_allocator_type& inner_allocator()noexcept;const inner_allocator_type& inner_allocator()constnoexcept; outer_allocator_type& outer_allocator()noexcept;const outer_allocator_type& outer_allocator()constnoexcept;   [[nodiscard]] pointer allocate(size_type n);[[nodiscard]] pointer allocate(size_type n, const_void_pointer hint);void deallocate(pointer p, size_type n); size_type max_size()const;   template<class T, class... Args>void construct(T* p, Args&&... args);   template<class T>void destroy(T* p);   scoped_allocator_adaptor select_on_container_copy_construction()const;};   template<class OuterAlloc, class... InnerAllocs> scoped_allocator_adaptor(OuterAlloc, InnerAllocs...)-> scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>;}