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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::tuple_cat -	std::tuple_cat

Synopsis
	  Defined in header <tuple>
	  template<		  class...		 Tuples		     >
       (since C++11)
	  std::tuple</*	 CTypes	 */...>	  tuple_cat(   Tuples&&...   args   );
       (until C++14)
	  template<		  class...		 Tuples		     >
       (since C++14)
	  constexpr std::tuple</* CTypes */...>	tuple_cat( Tuples&&... args );
       (until C++23)
	  template<		tuple-like...		  Tuples	     >
       (since C++23)
	  constexpr std::tuple</* CTypes */...>	tuple_cat( Tuples&&... args );

	  Constructs  a	 tuple	that is	a concatenation	of all tuples in args.
       The element types
	  /* CTypes */ of the returned tuple is	formed	by  concatenating  the
       elements	type
	  packs	of all
	  std::tuple
	  (until C++23)
	  tuple-like
	  (since C++23)	types in Tuples	in order.

	  The behavior is undefined if any type	in std::decay_t<Tuples>... is
	  not  a  specialization of std::tuple.	However, an implementation may
       (until C++23)
	  choose to support types (such	as std::array and std::pair) that fol-
       low
	  the tuple-like protocol.
	  The types std::decay_t<Tuples>... are	constrained to be tuple-like,
	  i.e. each type  therein  is  required	 to  be	 a  specialization  of
       (since C++23)
	  std::tuple or	another	type (such as std::array and std::pair)	that
	  models tuple-like.

	  If  any  type	 in /* CTypes */ is not	constructible from the type of
       the corresponding
	  element in the sequence of elements concatenated from	args,
	  the behavior is undefined
	  (until C++23)
	  the program is ill-formed
	  (since C++23).

Parameters
	  args - zero or more tuples to	concatenate

Return value
	  A std::tuple object composed of all elements of all argument	tuples
       constructed from
	  std::get<j>(std::forward<Ti>(arg)) for each individual element.

Example
       // Run this code

	#include <iostream>
	#include <string>
	#include <tuple>

	// helper function to print a tuple of any size
	template<class Tuple, std::size_t N>
	struct TuplePrinter
	{
	    static void	print(const Tuple& t)
	    {
		TuplePrinter<Tuple, N -	1>::print(t);
		std::cout << ",	" << std::get<N-1>(t);
	    }
	};

	template<class Tuple>
	struct TuplePrinter<Tuple, 1>
	{
	    static void	print(const Tuple& t)
	    {
		std::cout << std::get<0>(t);
	    }
	};

	template<typename... Args, std::enable_if_t<sizeof...(Args) == 0, int>
       = 0>
	void print(const std::tuple<Args...>& t)
	{
	    std::cout << "()\n";
	}

	template<typename... Args, std::enable_if_t<sizeof...(Args) != 0, int>
       = 0>
	void print(const std::tuple<Args...>& t)
	{
	    std::cout << "(";
	    TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
	    std::cout << ")\n";
	}
	// end helper function

	int main()
	{
	    std::tuple<int, std::string, float>	t1(10, "Test", 3.14);
	    int	n = 7;
	    auto  t2  =	 std::tuple_cat(t1, std::make_tuple("Foo", "bar"), t1,
       std::tie(n));
	    n =	42;
	    print(t2);
	}

Output:
	(10, Test, 3.14, Foo, bar, 10, Test, 3.14, 42)

See also
	  make_tuple	   creates a tuple object of the type defined  by  the
       argument	types
	  (C++11)	   (function template)
	  tie		    creates  a tuple of	lvalue references or unpacks a
       tuple into
	  (C++11)	   individual objects
			   (function template)
	  forward_as_tuple creates a tuple of forwarding references
	  (C++11)	   (function template)

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

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

home | help