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

NAME
     std::make_from_tuple - std::make_from_tuple

Synopsis
	Defined in header <tuple>
	template< class T, class Tuple >	   (since C++17)
	constexpr T make_from_tuple( Tuple&& t );  (until C++23)
	template< class T, tuple-like Tuple >	   (since C++23)
	constexpr T make_from_tuple( Tuple&& t );

	Construct  an object of type T, using the elements of the tuple t as the
     arguments to
	the constructor.

	Given the exposition-only function /*make-from-tuple-impl*/  defined  as
     follows:
	template<class	T,  tuple-like Tuple, std::size_t... I> // no constraint
     on Tuple
	before C++23
	constexpr   T	/*make-from-tuple-impl*/(Tuple&&    t,	  std::index_se-
     quence<I...>)
	{
	    return T(std::get<I>(std::forward<Tuple>(t))...);
	}

	The effect is equivalent to:
	return /*make-from-tuple-impl*/<T>(
	    std::forward<Tuple>(t),
	    std::make_index_sequence<std::tuple_size_v<std::remove_refer-
     ence_t<Tuple>>>{}
	);.

	If

	  *    std::tuple_size_v<std::remove_reference_t<Tuple>>    is	 1   and
     (since
	    std::reference_constructs_from_temporary_v<
     C++23)
		T, decltype(std::get<0>(std::declval<Tuple>()))> is true, or

	  *   std::is_constructible_v<T,   decltype(std::get<I>(std::declval<Tu-
     ple>()))...> is
	    false,

	the program is ill-formed.

Parameters
	t - tuple whose elements to be used as arguments to the constructor of T

Return value
	The constructed T object or reference.

Notes
	Tuple need not be std::tuple, and instead may be anything that
	supports  std::get  and  std::tuple_size;  in particular, std::array and
     (until C++23)
	std::pair may be used.
	Tuple is constrained to be tuple-like, i.e. each type therein is
	required to be a specialization of std::tuple or another type  (such  as
     (since C++23)
	std::array and std::pair) that models tuple-like.

	Due to guaranteed copy elision, T need not be movable.

	   Feature-test macro	   Value    Std 	Feature
	__cpp_lib_make_from_tuple 201606L (C++17) std::make_from_tuple

Example
     // Run this code

      #include <iostream>
      #include <tuple>

      struct Foo
      {
	  Foo(int first, float second, int third)
	  {
	      std::cout << first << ", " << second << ", " << third << '\n';
	  }
      };

      int main()
      {
	  auto tuple = std::make_tuple(42, 3.14f, 0);
	  std::make_from_tuple<Foo>(std::move(tuple));
      }

Output:
      42, 3.14, 0

	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 3528 C++17	    cast containing reinterpret_cast etc. was	    pro-
     hibited
			    allowed in the case of 1-tuple

See also
	make_tuple	 creates a tuple object of the type defined by the argu-
     ment types
	(C++11) 	 (function template)
	forward_as_tuple creates a tuple of forwarding references
	(C++11) 	 (function template)
	apply		 calls a function with a tuple of arguments
	(C++17) 	 (function template)

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