Namespaces
Variants

    std:: pointer_traits

    From es.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::pointer_traits
    Member functions
    (C++11)
    (C++20) (optional)
    Definido en el encabezado <memory>
    template < class Ptr >
    struct pointer_traits ;
    		(1) (desde C++11)
    template < class T >
    struct pointer_traits < T * > ;
    		(2) (desde C++11)

    La plantilla de clase pointer_traits proporciona la forma estandarizada de acceder a ciertas propiedades de tipos similares a punteros ( fancy pointers , como boost::interprocess::offset_ptr ). La plantilla estándar std::allocator_traits se basa en pointer_traits para determinar los valores predeterminados de varios typedefs requeridos por Allocator .

    1) La versión no especializada de pointer_traits declara condicionalmente los siguientes miembros:

    Sea /*element-type-of*/ < Ptr > igual a:

    • Ptr :: element_type si está presente;
    • en caso contrario, T si Ptr es una especialización de plantilla de clase Template < T, Args... > , donde Args... son cero o más argumentos de tipo;
    • en caso contrario, no está definido.

    Si /*element-type-of*/ < Ptr > no está definido, la plantilla principal no tiene miembros especificados en esta página.

    Contenido

    Tipos de miembros

    Tipo Definición
    pointer Ptr
    element_type /*element-type-of*/ < Ptr >
    difference_type Ptr :: difference_type si está presente, en caso contrario std::ptrdiff_t

    Plantillas de alias de miembros

    Plantilla Definición
    template < class U > using rebind Ptr :: rebind < U > si existe, en caso contrario Template < U, Args... > si Ptr es una especialización de plantilla Template < T, Args... >

    Funciones miembro

    [static]
    		obtiene un puntero dereferenciable a su argumento
    (función miembro pública estática)
    2) Se proporciona una especialización para tipos de puntero, T * , que declara los siguientes miembros:

    Tipos de miembros

    Tipo Definición
    pointer T *
    element_type T
    difference_type std::ptrdiff_t

    Plantillas de alias de miembros

    Plantilla Definición
    template < class U > using rebind U *

    Funciones de miembros

    [static]
    		obtiene un puntero dereferenciable a su argumento
    (función de miembro pública estática)

    Funciones miembro opcionales de especializaciones definidas por el programa

    [static] (C++20) (optional)
    		obtiene un puntero crudo desde un puntero sofisticado (inverso de pointer_to )
    (función miembro estática pública)

    Notas

    La plantilla de alias miembro rebind permite, dado un tipo similar a puntero que apunta a T , obtener el mismo tipo similar a puntero que apunta a U . Por ejemplo, 

    using another_pointer = std::pointer_traits<std::shared_ptr<int>>::rebind<double>;
static_assert(std::is_same<another_pointer, std::shared_ptr<double>>::value);

    Una especialización para tipos de punteros personalizados puede proporcionar una función miembro estática adicional to_address para personalizar el comportamiento de std::to_address .

    		(since C++20)
    Macro de prueba de características Valor Estándar Característica
    __cpp_lib_constexpr_memory 201811L (C++20) constexpr en std::pointer_traits

    Ejemplo

    Ejecutar este código 
    #include <iostream>
#include <memory>
template<class Ptr>
struct BlockList
{
    // Predefinir un bloque de memoria
    struct block;
    // Definir un puntero a un bloque de memoria del tipo de puntero Ptr
    // Si Ptr es cualquier tipo T*, block_ptr_t es block*
    // Si Ptr es smart_ptr<T>, block_ptr_t es smart_ptr<block>
    using block_ptr_t = typename std::pointer_traits<Ptr>::template rebind<block>;
    struct block
    {
        std::size_t size{};
        block_ptr_t next_block{};
    };
    block_ptr_t free_blocks;
};
int main()
{
    [[maybe_unused]]
    BlockList<int*> bl1;
    // El tipo de bl1.free_blocks es BlockList<int*>::block*
    BlockList<std::shared_ptr<char>> bl2;
    // El tipo de bl2.free_blocks es
    // std::shared_ptr<BlockList<std::shared_ptr<char>>::block>
    std::cout << bl2.free_blocks.use_count() << '\n';
}

    Salida: 

    ​0​

    Informes de defectos

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

    DR Aplicado a Comportamiento publicado Comportamiento correcto
    LWG 3545 C++11 la plantilla principal causaba un error grave cuando element_type es inválido hecho compatible con SFINAE

    Véase también

    (C++11)
    		proporciona información sobre tipos de allocator
    (class template)
    (C++11)
    		obtiene la dirección real de un objeto, incluso si el operador & está sobrecargado
    (function template)