##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::addressof

From cppreference.com
< cpp‎ | memory

Defined in header `<memory>` |  |
| (1) |
template< class T > T* addressof(T& arg); |  | (since C++11) (until C++17)
template< class T > constexpr T* addressof(T& arg); |  | (since C++17)
template <class T> const T* addressof(const T&&) = delete; | (2) | (since C++17)

1) Obtains the actual address of the object or function `arg`, even in presence of overloaded `operator&`
2) Rvalue overload is deleted to prevent taking the address of const rvalues.

The expression `std::addressof(E)` is a constant subexpression, if `E` is an lvalue constant subexpression. | (since C++17)

### [edit] Parameters

arg | - | lvalue object or function

### [edit] Return value

Pointer to `arg`.

### [edit] Exceptions

1)
`noexcept` specification:
noexcept

### [edit] Possible implementation

    template< class T >
    T* addressof(T& arg)
    {
        return reinterpret_cast<T*>(
                   &const_cast<char&>(
                      reinterpret_cast<const volatile char&>(arg)));
    }

Note: the above implementation is oversimplified and is not `constexpr` (which requires compiler support).

### [edit] Example

operator& may be overloaded for a pointer wrapper class to obtain a pointer to pointer:

Run this code

    #include <iostream>
    #include <memory>

    template<class T>
    struct Ptr {
        T* pad; // add pad to show difference between 'this' and '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   overload called with p = " << p << '\n';
    }

    void f(int** p)
    {
        std::cout << "int** overload called with p = " << p << '\n';
    }

    int main()
    {
        Ptr<int> p(new int(42));
        f(&p);                 // calls int** overload
        f(std::addressof(p));  // calls Ptr<int>* overload, (= this)
    }

Possible output:

    Ctor this = 0x7fff59ae6e88
    int** overload called with p = 0x7fff59ae6e90
    Ptr   overload called with p = 0x7fff59ae6e88

### [edit] See also

allocator | the default allocator (class template) [edit]
pointer_to [static] | obtains a dereferenceable pointer to its argument (public static member function of `std::pointer_traits`) [edit]

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/memory/addressof&oldid=91358"
Category:

- unconditionally noexcept

Hidden categories:

- Pages with unreviewed unconditional noexcept template
- Pages with unreviewed noexcept template