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

NAME
     std::construct_at - std::construct_at

Synopsis
	Defined in header <memory>
	template< class T, class... Args >		    (since C++20)
	constexpr T* construct_at( T* p, Args&&... args );

	Creates  a  T object initialized with arguments args... at given address
     p.
	Specialization of this function template participates in overload  reso-
     lution only if
	::new(std::declval<void*>())  T(std::declval<Args>()...)  is well-formed
     in an
	unevaluated context.

	Equivalent to

      return ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);

	except that construct_at may be used in evaluation of  constant  expres-
     sions.

	When  construct_at  is called in the evaluation of some constant expres-
     sion e, the
	argument p  must  point  to  either  storage  obtained	by  std::alloca-
     tor<T>::allocate or
	an object whose lifetime began within the evaluation of e.

Parameters
	p	 - pointer to the uninitialized storage on which a T object will
     be
		  constructed
	args... - arguments used for initialization

Return value
	p

Example
     // Run this code

      #include <bit>
      #include <memory>

      class S
      {
	  int x_;
	  float y_;
	  double z_;
      public:
	  constexpr S(int x, float y, double z) : x_{x}, y_{y}, z_{z} {}
	  [[nodiscard("no side-effects!")]]
	  constexpr bool operator==(const S&) const noexcept = default;
      };

      consteval bool test()
      {
	  alignas(S) unsigned char storage[sizeof(S)]{};
	  S uninitialized = std::bit_cast<S>(storage);
	  std::destroy_at(&uninitialized);
	  S* ptr = std::construct_at(std::addressof(uninitialized),  42,  2.71f,
     3.14);
	  const bool res{*ptr == S{42, 2.71f, 3.14}};
	  std::destroy_at(ptr);
	  return res;
      }
      static_assert(test());

      int main() {}

	Defect reports

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

	   DR	 Applied to	  Behavior as published 	     Correct be-
     havior
	LWG 3870 C++20	    construct_at could create objects  only  cv-unquali-
     fied types are
			    of a cv-qualified types	       permitted

See also
	allocate	     allocates uninitialized storage
			     (public member function of std::allocator<T>)
	construct	     constructs an object in the allocated storage
	[static]	     (function template)
	destroy_at	     destroys an object at a given address
	(C++17) 	     (function template)
	ranges::construct_at creates an object at a given address
	(C++20) 	     (niebloid)

http://cppreference.com 	   2024.06.10		    std::construct_at(3)
home | help