Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::addressof(3)	      C++ Standard Libary	     std::addressof(3)

NAME
       std::addressof -	std::addressof

Synopsis
	  Defined in header <memory>
	  template< class T >			    (1)	(since C++11)
	  T*  addressof(  T&  arg  )  noexcept;		      (constexpr since
       C++17)
	  template< class T >			    (2)	(since C++11)
	  const	T* addressof( const T&&	) = delete;

	  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 std::addressof(e) is a	constant subexpression,	 if  e
       is  (since C++17)
	  an lvalue constant subexpression.

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  addres-
       sof(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 addres-
       sof(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::addres-
       sof

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

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

	  Defect reports

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

	     DR	   Applied to	       Behavior	as published		  Cor-
       rect behavior
	  LWG 2598 C++11      std::addressof<const T> could take	disal-
       lowed by	a deleted
			      address  of  rvalues			 over-
       load

See also
	  allocator  the default allocator
		     (class template)
	  pointer_to obtains a dereferenceable pointer to its argument
	  [static]	 (public      static	  member      function	    of
       std::pointer_traits<Ptr>)

http://cppreference.com		  2024.06.10		     std::addressof(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::addressof&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help