Namespaces
Variants

std:: allocator

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::allocator
Definido en el encabezado <memory>
template < class T >
struct allocator ;
(1)
template <>
struct allocator < void > ;
(2) (obsoleto en C++17)
(eliminado en C++20)

La clase plantilla std::allocator es el Allocator predeterminado utilizado por todos los contenedores de la biblioteca estándar si no se proporciona un asignador especificado por el usuario. El asignador predeterminado no tiene estado, es decir, todas las instancias del asignador dado son intercambiables, se comparan iguales y pueden desasignar memoria asignada por cualquier otra instancia del mismo tipo de asignador.

La especialización explícita para void carece de los typedefs de miembro reference , const_reference , size_type y difference_type . Esta especialización no declara funciones miembro.

(hasta C++20)

El asignador por defecto satisface los requisitos de completitud del asignador .

(desde C++17)

Contenidos

Tipos de miembros

Tipo Definición
value_type T
pointer (obsoleto en C++17) (eliminado en C++20) T*
const_pointer (obsoleto en C++17) (eliminado en C++20) const T *
reference (obsoleto en C++17) (eliminado en C++20) T&
const_reference (obsoleto en C++17) (eliminado en C++20) const T &
size_type std::size_t
difference_type std::ptrdiff_t
propagate_on_container_move_assignment (C++11) std::true_type
rebind (obsoleto en C++17) (eliminado en C++20) template < class U >

struct rebind
{
typedef allocator < U > other ;
} ;

is_always_equal (C++11) (obsoleto en C++23) (eliminado en C++26) std::true_type

Funciones miembro

crea una nueva instancia del asignador
(función de miembro pública)
destruye una instancia del asignador
(función de miembro pública)
(until C++20)
obtiene la dirección de un objeto, incluso si operator & está sobrecargado
(función de miembro pública)
asigna almacenamiento no inicializado
(función de miembro pública)
(C++23)
asigna almacenamiento no inicializado al menos del tamaño solicitado
(función de miembro pública)
libera almacenamiento
(función de miembro pública)
(until C++20)
devuelve el tamaño de asignación más grande admitido
(función de miembro pública)
(until C++20)
construye un objeto en almacenamiento asignado
(función de miembro pública)
(until C++20)
destruye un objeto en almacenamiento asignado
(función de miembro pública)

Funciones no miembro

(removed in C++20)
compara dos instancias de allocator
(función miembro pública)

Notas

La clase plantilla miembro rebind proporciona una forma de obtener un asignador para un tipo diferente. Por ejemplo, std:: list < T, A > asigna nodos de algún tipo interno Node<T> , utilizando el asignador A::rebind<Node<T>>::other (hasta C++11) std:: allocator_traits < A > :: rebind_alloc < Node < T >> , que se implementa en términos de A::rebind<Node<T>>::other si A es un std::allocator (desde C++11) .

El tipo miembro is_always_equal está obsoleto según LWG issue 3170 , porque hace que los asignadores personalizados derivados de std::allocator se traten como siempre iguales por defecto. std:: allocator_traits < std :: allocator < T >> :: is_always_equal no está obsoleto y su constante miembro value es true para cualquier T .

Ejemplo

Ejecutar este código 
#include <iostream>
#include <memory>
#include <string>
int main()
{
    // asignador predeterminado para enteros
    std::allocator<int> alloc1;
    // demostrando los pocos miembros directamente utilizables
    static_assert(std::is_same_v<int, decltype(alloc1)::value_type>);
    int* p1 = alloc1.allocate(1); // espacio para un entero
    alloc1.deallocate(p1, 1);     // y desaparece
    // Aunque estos también pueden usarse mediante traits, así que no es necesario
    using traits_t1 = std::allocator_traits<decltype(alloc1)>; // El trait correspondiente
    p1 = traits_t1::allocate(alloc1, 1);
    traits_t1::construct(alloc1, p1, 7);  // construir el entero
    std::cout << *p1 << '\n';
    traits_t1::deallocate(alloc1, p1, 1); // desasignar espacio para un entero
    // asignador predeterminado para cadenas
    std::allocator<std::string> alloc2;
    // traits correspondientes
    using traits_t2 = std::allocator_traits<decltype(alloc2)>;
    // Reasignando el asignador usando el trait para cadenas obtiene el mismo tipo
    traits_t2::rebind_alloc<std::string> alloc_ = alloc2;
    std::string* p2 = traits_t2::allocate(alloc2, 2); // espacio para 2 cadenas
    traits_t2::construct(alloc2, p2, "foo");
    traits_t2::construct(alloc2, p2 + 1, "bar");
    std::cout << p2[0] << ' ' << p2[1] << '\n';
    traits_t2::destroy(alloc2, p2 + 1);
    traits_t2::destroy(alloc2, p2);
    traits_t2::deallocate(alloc2, p2, 2);
}

Salida: 

7
foo bar

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2103 C++11 podría requerirse comparación redundante entre allocator propagate_on_container_move_assignment proporcionado
LWG 2108 C++11 no existía forma de mostrar que allocator es sin estado is_always_equal proporcionado

Véase también

(C++11)
proporciona información sobre tipos de allocator
(class template)
(C++11)
implementa allocator multinivel para contenedores multinivel
(class template)
(C++11)
verifica si el tipo especificado soporta construcción uses-allocator
(class template)