std::addressof - cppreference.com

De cppreference.com

</tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody>

Definido en el archivo de encabezado `<memory>`
	(1)
`template< class T > T* addressof(T& arg) noexcept;`			(desde C++11) (hasta C++17)
`template< class T > constexpr T* addressof(T& arg) noexcept;`			(desde C++17)
`template <class T> const T* addressof(const T&&) = delete;`		(2)	(desde C++17)

1) Obtiene la dirección actual del objeto o función arg, aún en la presencia de un operador operator& sobrecargado.

2) La sobrecarga r-valor se elimina para prevenir la toma de la dirección de r-valores const.

La expresión std::addressof(E) es una subexpresión constante, si E es una subexpresión l-valor constante.

(desde C++17)

Parámetros

arg

Objeto l-valor o función

Valor de retorno

Puntero a arg.

Posible implementación

template<class T>
typename std::enable_if<std::is_object<T>::value, T*>::type  addressof(T& arg) noexcept
{
    return reinterpret_cast<T*>(
               &const_cast<char&>(
                   reinterpret_cast<const volatile char&>(arg)));
}

template<class T>
typename std::enable_if<!std::is_object<T>::value, T*>::type addressof(T& arg) noexcept
{
    return &arg;
}

Nota: la implementación anterior no es constexpr (lo que requiere soporte del compilador).

Ejemplo

operator& puede estar sobrecargado para una clase de envoltorio de puntero para obtener un puntero a puntero:

#include <iostream>
#include <memory>

template<class T>
struct Ptr {
    T* pad; // añadir pad para mostrar diferencia entre 'this' y 'data'
    T* data;
    Ptr(T* arg) : pad(nullptr), data(arg) 
    {
        std::cout << "Ctor this = " << this << std::endl;
    }

    ~Ptr() { delete data; }
    T** operator&() { return &data; }
};

template<class T>
void f(Ptr<T>* p) 
{
    std::cout << "Ptr   sobrecarga llamada con p = " << p << '\n';
}

void f(int** p) 
{
    std::cout << "int** sobrecarga llamada con p = " << p << '\n';
}

int main() 
{
    Ptr<int> p(new int(42));
    f(&p);                 // llama a la sobrecarga int**
    f(std::addressof(p));  // llama a la sobrecarga Ptr<int>*, (= this)
}

Posible salida:

Ctor this = 0x7fff59ae6e88
int** sobrecarga llamada con p = 0x7fff59ae6e90
Ptr   sobrecarga llamada con p = 0x7fff59ae6e88

Véase también

	El asignador de memoria por defecto. (plantilla de clase) [editar]
	Obtiene un puntero desreferenciable a su argumento. (función miembro estática pública de `std::pointer_traits<Ptr>`) [editar]