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

Obtain the address represented by p without forming a reference to the object pointed to by p.

1. Fancy pointer overload: If the expression std::pointer_traits<Ptr>::to_address(p) is well-formed, returns the result of that expression. Otherwise, returns std::to_address(p.operator->()).

2. Raw pointer overload: If T is a function type, the program is ill-formed. Otherwise, returns p unmodified.

Contents

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

[edit] Parameters

[edit] Return value

Raw pointer that represents the same address as p does.

[edit] Possible implementation

template constexpr T* to_address(T* p) noexcept { static_assert(); return p; }   template constexpr auto to_address(const T& p) noexcept { if constexpr (requires{ std::pointer_traits::to_address(p); }) return std::pointer_traits::to_address(p); else return std::to_address(p.operator->()); }

[edit] Notes

std::to_address can be used even when p does not reference storage that has an object constructed in it, in which case std::addressof(*p) cannot be used because there is no valid object for the parameter of std::addressof to bind to.

The fancy pointer overload of std::to_address inspects the std::pointer_traits<Ptr> specialization. If instantiating that specialization is itself ill-formed (typically because element_type cannot be defined), that results in a hard error outside the immediate context and renders the program ill-formed.

std::to_address may additionally be used on iterators that satisfy std::contiguous_iterator.

[edit] Example

#include   template auto allocator_new(A& a) { auto p = a.allocate(1); try { std::allocator_traits::construct(a, std::to_address(p)); } catch (...) { a.deallocate(p, 1); throw; } return p; }   template void allocator_delete(A& a, typename std::allocator_traits::pointer p) { std::allocator_traits::destroy(a, std::to_address(p)); a.deallocate(p, 1); }   int main() { std::allocator a; auto p = allocator_new(a); allocator_delete(a, p); }

[edit] See also

| | provides information about pointer-like types (class template) [edit] | | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | [static] (C++20)(optional) | obtains a raw pointer from a fancy pointer (inverse of pointer_to) (public static member function of std::pointer_traits) [edit] |