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

FreeBSD Manual Pages

  
 
  

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 con-
       straint 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
       Correct behavior
	  LWG  3528  C++17	 cast  containing  reinterpret_cast  etc.  was
       prohibited
			      allowed in the case of 1-tuple

See also
	  make_tuple	   creates a tuple object of the type defined  by  the
       argument	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)

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

home | help