Difference between revisions of "cpp/memory/addressof"
From cppreference.com
| Line 11: | Line 11: | ||
template< class T > | template< class T > | ||
constexpr T* addressof(T& arg) noexcept; | constexpr T* addressof(T& arg) noexcept; | ||
| − | |||
| − | |||
| − | |||
| − | |||
const T* addressof(const T&&) = delete; | const T* addressof(const T&&) = delete; | ||
}} | }} | ||
| Line 40: | Line 36: | ||
===Possible implementation=== | ===Possible implementation=== | ||
| − | {{ | + | {{example |
| − | | | + | | code= |
template<class T> | template<class T> | ||
constexpr auto addressof(T& arg) noexcept | constexpr auto addressof(T& arg) noexcept | ||
| Line 47: | Line 43: | ||
return __builtin_addressof(arg); | return __builtin_addressof(arg); | ||
} | } | ||
| − | + | | | |
| + | }} | ||
Note: the above implementation is not {{tt|constexpr}} (which requires compiler support). | Note: the above implementation is not {{tt|constexpr}} (which requires compiler support). | ||
Revision as of 12:30, 23 July 2021
| 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) | |
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.
WARNINGS
std::addressof is not available in freestanding environment. You cannot use std::move to write OS kernel or embedded system.
Possible implementation
Run this code
template<class T> constexpr auto addressof(T& arg) noexcept { return __builtin_addressof(arg); }
Note: the above implementation is not constexpr (which requires compiler support).
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
See also
| the default allocator (class template) | |
| [static] |
obtains a dereferenceable pointer to its argument (public static member function of std::pointer_traits<Ptr>)
|
