std::addressof
Defined in header <memory> | ||
---|---|---|
(1) | ||
template< class T >
T* addressof(T& arg) noexcept;
| (since C++11) (until C++17) | |
template< class T >
constexpr T* addressof(T& arg) noexcept;
| (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 | (since C++17) |
Parameters
arg | - | lvalue object or function |
Return value
Pointer to arg
.
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).
Example
operator& may be overloaded for a pointer wrapper class to obtain a pointer to pointer:
#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
See also
the default allocator (class template) |
|
[static] | obtains a dereferenceable pointer to its argument (public static member function of std::pointer_traits<Ptr> ) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/memory/addressof