std::addressof
From cppreference.com
                    
                                        
                    
                    
                                                            
                    | 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  | (since C++17) | 
| Contents | 
[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
| the default allocator (class template) | |
| [static] | obtains a dereferenceable pointer to its argument (public static member function of std::pointer_traits) | 


