std::to_address

Obtiene la dirección representada por p sin formar una referencia al objeto al que apunta p.

[editar] Parámetros

[editar] Valor de retorno

Puntero sin formato que representa la misma dirección que p.

[editar] Posible implementación

template<class T>
constexpr T* to_address(T* p) noexcept
{
    static_assert(!std::is_function_v<T>);
    return p;
}
 
template<class T>
constexpr auto to_address(const T& p) noexcept
{
    if constexpr (requires{ std::pointer_traits<T>::to_address(p); }) {
        return std::pointer_traits<T>::to_address(p);
    } else {
        return std::to_address(p.operator->());
    }
}

[editar] Notas

std::to_address puede usarse incluso cuando p no hace referencia a almacenamiento que tiene un objeto construido en él, en cuyo caso std::addressof(*p) no se puede usar porque no hay un objeto válido al que el parámetro de std::addressof se vincule.

La sobrecarga de puntero sofisticado de to_address inspecciona la especialización std::pointer_traits<Ptr>. Si instanciar esa especialización está en sí mismo mal formado (típicamente porque element_type no puede definirse), eso da como resultado un error insalvable fuera del contexto inmediato y hace que el programa esté mal formado.

[editar] Ejemplo

#include <memory>
 
template<class A>
auto allocator_new(A& a)
{
    auto p = a.allocate(1);
    try {
        std::allocator_traits<A>::construct(a, std::to_address(p));
    } catch (...) {
        a.deallocate(p, 1);
        throw;
    }
    return p;
}
 
template<class A>
void allocator_delete(A& a, typename std::allocator_traits<A>::pointer p)
{
    std::allocator_traits<A>::destroy(a, std::to_address(p));
    a.deallocate(p, 1);
}
 
int main()
{
    std::allocator<int> a;
    auto p = allocator_new(a);
    allocator_delete(a, p);
}

[editar] Véase también