std::addressof - cppreference.com (original) (raw)

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.

Contents

• 1 Parameters
• 2 Return value
• 3 Possible implementation
• 4 Notes
• 5 Example
• 6 Defect reports
• 7 See also

[edit] Parameters

[edit] Return value

Pointer to arg.

[edit] Possible implementation

The implementation below is not constexpr, because reinterpret_cast is not usable in a constant expression. Compiler support is needed (see below).

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

Correct implementation of this function requires compiler support: GNU libstdc++, LLVM libc++, Microsoft STL.

[edit] Notes

constexpr for addressof is added by LWG2296, and MSVC STL applies the change to C++14 mode as a defect report.

There are some weird cases where use of built-in operator& is ill-formed due to argument-dependent lookup even if it is not overloaded, and std::addressof can be used instead.

template struct holder { T t; };   struct incomp;   int main() { holder<holder*> x{}; // &x; // error: argument-dependent lookup attempts to instantiate holder std::addressof(x); // OK }

[edit] Example

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

#include #include   template 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 << '\n'; }   ~Ptr() { delete data; } T** operator&() { return &data; } };   template void f(Ptr* 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 p(new int(42)); f(&p); // calls int** overload f(std::addressof(p)); // calls Ptr* overload, (= this) }

Possible output:

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

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also

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