Difference between revisions of "cpp/memory/addressof"
From cppreference.com
(Clarify why compiler support is needed. See https://stackoverflow.com/q/76594664/5740428) |
m (→Synopsis: {{mark constexpr since c++17}}) |
||
| Line 3: | Line 3: | ||
{{dcl begin}} | {{dcl begin}} | ||
{{dcl header|memory}} | {{dcl header|memory}} | ||
| − | {{dcl | + | {{dcl|num=1|since=c++11|notes={{mark constexpr since c++17}}| |
| − | + | ||
template< class T > | template< class T > | ||
T* addressof( T& arg ) noexcept; | T* addressof( T& arg ) noexcept; | ||
}} | }} | ||
| − | |||
| − | |||
| − | |||
| − | |||
| − | |||
{{dcl|since=c++17|num=2|1= | {{dcl|since=c++17|num=2|1= | ||
template< class T > | template< class T > | ||
| Line 56: | Line 50: | ||
===Notes=== | ===Notes=== | ||
| − | {{feature test macro|__cpp_lib_addressof_constexpr|std=C++17|value=201603L|{{c|constexpr}} {{ | + | {{feature test macro|__cpp_lib_addressof_constexpr|std=C++17|value=201603L|{{c|constexpr}} {{tt|std::addressof}}}} |
===Example=== | ===Example=== | ||
Revision as of 07:22, 20 September 2023
| Defined in header <memory>
|
||
| template< class T > T* addressof( T& arg ) noexcept; |
(1) | (since C++11) (constexpr 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 |
Parameters
| arg | - | lvalue object or function |
Return value
Pointer to arg.
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<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; } |
Correct implementation of this function requires compiler support: GNU libstdc++, LLVM libc++, Microsoft STL.
Notes
| Feature-test macro | Value | Std | Feature |
|---|---|---|---|
__cpp_lib_addressof_constexpr |
201603L | (C++17) | constexpr std::addressof
|
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 << '\n'; } ~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>)
|
