std::scoped_allocator_adaptor::construct

Construye un objeto en almacenamiento asignado, pero no inicializado, al que apunta p usando OuterAllocator y los argumentos del constructor proporcionados. Si el objeto es del tipo que utiliza asignadores, o si es std::pair, pasa InnerAllocator al objeto construido.

Primero, recupera el asignador más externo MÁSEXTERNO llamando a this->outer_allocator(), y luego llama a la función miembro outer_allocator() recursivamente en el resultado de esta llamada hasta llegar a un asignador que no tiene tal función miembro.

Define RASGOS_DE_ASIGNADOR_MÁSEXTERNO(x) como std::allocator_traits<std::remove_reference_t<decltype(MÁSEXTERNO(x))>>.

std::apply(
    [p,this](auto&&... newargs) {
        RASGOS_DE_ASIGNADOR_MÁSEXTERNO(*this)::construct(
            MÁSEXTERNO(*this), p, std::forward<decltype(newargs)>(newargs)...);
    },
    std::uses_allocator_construction_args(
        inner_allocator(),
        std::forward<Args>(args)...
    )
);

std::tuple_cat(std::tuple<std::allocator_arg_t, inner_allocator_type&>(
                    std::allocator_arg, inner_allocator()
               ),
               std::tuple<Args1&&...>(std::move(x)))

std::allocator_traits<O>::construct( MÁSEXTERNO,
                                     p,
                                     std::piecewise_construct,
                                     std::move(xprime),
                                     std::move(yprime));

construct(p, std::piecewise_construct, std::forward_as_tuple(std::forward<U>(x)),
                                       std::forward_as_tuple(std::forward<V>(y)))

construct(p, std::piecewise_construct, std::forward_as_tuple(xy.first),
                                       std::forward_as_tuple(xy.second))

construct(p, std::piecewise_construct,
             std::forward_as_tuple(std::forward<U>(xy.first)),
             std::forward_as_tuple(std::forward<V>(xy.second)))

template< class A, class B >
void /*deducir-como-par*/( const std::pair<A, B>& );

construct<T1, T2, T1, T2>(p, std::forward<NonPair>(non_pair));

[editar] Parámetros

[editar] Valor de retorno

(Ninguno)

[editar] Notas

Esta función se llama (a través de std::allocator_traits) por cualquier objeto consciente de asignador, como std::vector, que le fue dado un std::scoped_allocator_adaptor como el asignador a usar. Ya que inner_allocator es en sí mismo una instancia de std::scoped_allocator_adaptor, esta función también se llamará cuando los objetos conscientes de asignador construidos a través de esta función comiencen a construir sus propios miembros.

[editar] Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

[editar] Véase también