C++/Tuple

<tuple> 是从C++11正式引入C++标准程式库中的一个头文件，定义了C++标准支持的包含固定个数的元素的容器，这些元素可以是不同数据类型。

类（模板）

• tuple：类模板，实现了一种容器，包含的元素个数固定，元素可以是不同类项。是std::pair的推广。
  • tuple的初始化构造函数都是explicit，所以tuple<int,int> t(1,2);通过编译而tuple<int,int> t2 ={1,2}; 报错
• tuple_size<tuple_type>::value：类模板特化，编译时获得tuple、pair、array的元素个数
• tuple_element<idx,tupletype>::type：类模板特化，获取特定元素的类型
• std::uses_allocator<std::tuple>：类模板特化，指出std::uses_allocator的type trait

常量

• ignore：使用tie解开一个tuple时，跳过一个元素的占位符

函数（模板）

• make_tuple：函数模板，创建一个tuple对象
• tie：函数模板，创建一个完全由左值引用作为实参而构造出的tuple，其效果相当于解开（unpack）一个tuple的当前值赋给一组单个的对象；其中不关心的元素用std::ignore对应。例如：std::tuple<int,std::ignore,string> t(1,2,"hello");
• forward_as_tuple：函数模板，创建一个引用到实参的tuple。如果实参为右值，tuple的数据成员是右值引用；否则为左值引用。
• tuple_cat：函数模板，通过连接任意数量的tuple来创建一个tuple
• std::get<size_t index>(std::tuple)或者std::get<typename>(std::tuple)：函数模板，访问tuple的特定元素
• operator== ：函数模板，
• operator!= ：函数模板，
• operator< ：函数模板，
• operator<= ：函数模板，
• operator> ：函数模板，
• operator>= ：函数模板，
• std::swap(std::tuple)：函数模板，std::swap算法的特化
• apply：函数模板，C++17引入。调用一个函数，使用tuple作为实参
• make_from_tuple：函数模板，C++17引入。构造一个对象，使用tuple作为实参

例子

#include <iostream>
#include <tuple>
#include <functional>

int main()
{
    auto t1 = std::make_tuple(10, "Test", 3.14);
    std::cout << "The value of t1 is "
              << "(" << std::get<0>(t1) << ", " << std::get<1>(t1)
              << ", " << std::get<2>(t1) << ")\n";

    int n = 1;
    auto t2 = std::make_tuple(std::ref(n), n);
    n = 7;
    std::cout << "The value of t2 is "
              << "(" << std::get<0>(t2) << ", " << std::get<1>(t2) << ")\n";
}

运行结果为：

The value of t1 is (10, Test, 3.14)
The value of t2 is (7, 1)

下属例子对于函数或成员函数f，传入一个元组作为参数并转化为不定长参数调用：

  

#include <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>

template<size_t N>
struct Apply {  // convert the n-element tuple to variable-length parameter
	template<typename F, typename T, typename... A>
	static inline auto apply(F && f, T && t, A &&... a)
		-> decltype(Apply<N - 1>::apply(
			::std::forward<F>(f), ::std::forward<T>(t),
			::std::get<N - 1>(::std::forward<T>(t)), ::std::forward<A>(a)...
		))
	{
		return Apply<N - 1>::apply(::std::forward<F>(f), ::std::forward<T>(t),
			::std::get<N - 1>(::std::forward<T>(t)), ::std::forward<A>(a)...
		);
	}
};

template<>
struct Apply<0> {
	template<typename F, typename T, typename... A>
	static inline auto apply(F && f, T &&, A &&... a)
		-> decltype(::std::forward<F>(f)(::std::forward<A>(a)...))
	{
		return ::std::forward<F>(f)(::std::forward<A>(a)...);
	}
};

template<typename F, typename T>
inline auto apply(F && f, T && t)  // call f by tuple t as parameter 
  -> decltype(Apply< ::std::tuple_size<	typename ::std::decay<T>::type>::value 
                   >::apply(::std::forward<F>(f), ::std::forward<T>(t)))
{
	return Apply< ::std::tuple_size<typename ::std::decay<T>::type>::value
	            >::apply
	(::std::forward<F>(f), ::std::forward<T>(t));
}


using std::forward; // You can change this if you like unreadable code or care hugely about namespace pollution.

template<size_t N>
struct ApplyMember
{
	template<typename C, typename F, typename T, typename... A>
	static inline auto apply(C&& c, F&& f, T&& t, A&&... a) ->
		decltype(ApplyMember<N - 1>::apply(forward<C>(c), forward<F>(f), forward<T>(t), std::get<N - 1>(forward<T>(t)), forward<A>(a)...))
	{
		return ApplyMember<N - 1>::apply(forward<C>(c), forward<F>(f), forward<T>(t), std::get<N - 1>(forward<T>(t)), forward<A>(a)...);
	}
};

template<>
struct ApplyMember<0>
{
	template<typename C, typename F, typename T, typename... A>
	static inline auto apply(C&& c, F&& f, T&&, A&&... a) ->
		decltype((forward<C>(c)->*forward<F>(f))(forward<A>(a)...))
	{
		return (forward<C>(c)->*forward<F>(f))(forward<A>(a)...);
	}
};

// C is the class, F is the member function, T is the tuple.
template<typename C, typename F, typename T>
inline auto apply(C&& c, F&& f, T&& t) ->
decltype(ApplyMember<std::tuple_size<typename std::decay<T>::type>::value>::apply(forward<C>(c), forward<F>(f), forward<T>(t)))
{
	return ApplyMember<std::tuple_size<typename std::decay<T>::type>::value>::apply(forward<C>(c), forward<F>(f), forward<T>(t));
}

一个完整、详尽例子：

#include "tuple.hpp"
#include <iostream>
#include <tuple>
#include <string>
#include <functional>
#include <utility>

//////////////////////////////////////////////////////////
// reference: http://www.cplusplus.com/reference/tuple/tuple/
int test_tuple_4()
{
{ // tuple::tuple: Constructs a tuple object. This involves individually constructing its elements,
  // with an initialization that depends on the constructor form invoke
	std::tuple<int, char> first;                             // default
	std::tuple<int, char> second(first);                    // copy
	std::tuple<int, char> third(std::make_tuple(20, 'b'));   // move
	std::tuple<long, char> fourth(third);                   // implicit conversion
	std::tuple<int, char> fifth(10, 'a');                    // initialization
	std::tuple<int, char> sixth(std::make_pair(30, 'c'));    // from pair / move

	std::cout << "sixth contains: " << std::get<0>(sixth);
	std::cout << " and " << std::get<1>(sixth) << '\n';
}

{ // std::tuple::operator=: Each of the elements in the tuple object is assigned its corresponding element
	std::pair<int, char> mypair(0, ' ');

	std::tuple<int, char> a(10, 'x');
	std::tuple<long, char> b, c;

	b = a;                                // copy assignment
	c = std::make_tuple(100L, 'Y');       // move assignment
	a = c;                                // conversion assignment
	c = std::make_tuple(100, 'z');        // conversion / move assignment
	a = mypair;                           // from pair assignment
	a = std::make_pair(2, 'b');           // form pair /move assignment

	std::cout << "c contains: " << std::get<0>(c);
	std::cout << " and " << std::get<1>(c) << '\n';
}

{ // std::tuple::swap: Exchanges the content of the tuple object by the content of tpl,
  // which is another tuple of the same type (containing objects of the same types in the same order)
	std::tuple<int, char> a(10, 'x');
	std::tuple<int, char> b(20, 'y');

	a.swap(b);
	std::cout << "a contains: " << std::get<0>(a);
	std::cout << " and " << std::get<1>(a) << '\n';

	std::swap(a, b);
	std::cout << "a contains: " << std::get<0>(a);
	std::cout << " and " << std::get<1>(a) << '\n';
}

{ // std::relational operators: Performs the appropriate comparison operation between the tuple objects lhs and rhs
	std::tuple<int, char> a(10, 'x');
	std::tuple<char, char> b(10, 'x');
	std::tuple<char, char> c(10, 'y');

	if (a == b) std::cout << "a and b are equal\n";
	if (b != c) std::cout << "b and c are not equal\n";
	if (b<c) std::cout << "b is less than c\n";
	if (c>a) std::cout << "c is greater than a\n";
	if (a <= c) std::cout << "a is less than or equal to c\n";
	if (c >= b) std::cout << "c is greater than or equal to b\n";
}

	return 0;
}

////////////////////////////////////////////////
// reference: https://msdn.microsoft.com/en-us/library/bb982771.aspx
int test_tuple_3()
{
	typedef std::tuple<int, double, int, double> Mytuple;

	Mytuple c0(0, 1, 2, 3);
	// display contents " 0 1 2 3" 
	std::cout << " " << std::get<0>(c0);
	std::cout << " " << std::get<1>(c0);
	std::cout << " " << std::get<2>(c0);
	std::cout << " " << std::get<3>(c0);
	std::cout << std::endl;

	Mytuple c1;
	c1 = c0;
	// display contents " 0 1 2 3" 
	std::cout << " " << std::get<0>(c1);
	std::cout << " " << std::get<1>(c1);
	std::cout << " " << std::get<2>(c1);
	std::cout << " " << std::get<3>(c1);
	std::cout << std::endl;

	std::tuple<char, int> c2(std::make_pair('x', 4));
	// display contents " x 4" 
	std::cout << " " << std::get<0>(c2);
	std::cout << " " << std::get<1>(c2);
	std::cout << std::endl;

	Mytuple c3(c0);
	// display contents " 0 1 2 3" 
	std::cout << " " << std::get<0>(c3);
	std::cout << " " << std::get<1>(c3);
	std::cout << " " << std::get<2>(c3);
	std::cout << " " << std::get<3>(c3);
	std::cout << std::endl;

	typedef std::tuple<int, float, int, float> Mytuple2;

	Mytuple c4(Mytuple2(4, 5, 6, 7));
	// display contents " 4 5 6 7" 
	std::cout << " " << std::get<0>(c4);
	std::cout << " " << std::get<1>(c4);
	std::cout << " " << std::get<2>(c4);
	std::cout << " " << std::get<3>(c4);
	std::cout << std::endl;

	return (0);
}

///////////////////////////////////////////////////
// reference: http://zh.cppreference.com/w/cpp/utility/tuple
static std::tuple<double, char, std::string> get_student(int id)
{
	if (id == 0) return std::make_tuple(3.8, 'A', "Lisa Simpson");
	if (id == 1) return std::make_tuple(2.9, 'C', "Milhouse Van Houten");
	if (id == 2) return std::make_tuple(1.7, 'D', "Ralph Wiggum");
	throw std::invalid_argument("id");
}

int test_tuple_2()
{
	auto student0 = get_student(0);
	std::cout << "ID: 0, "
		<< "GPA: " << std::get<0>(student0) << ", "
		<< "grade: " << std::get<1>(student0) << ", "
		<< "name: " << std::get<2>(student0) << '\n';

	double gpa1;
	char grade1;
	std::string name1;
	std::tie(gpa1, grade1, name1) = get_student(1);
	std::cout << "ID: 1, "
		<< "GPA: " << gpa1 << ", "
		<< "grade: " << grade1 << ", "
		<< "name: " << name1 << '\n';

	return 0;
}

///////////////////////////////////////////////
// reference: http://www.cplusplus.com/reference/tuple/
static void print_pack(std::tuple<std::string&&, int&&> pack)
{
	std::cout << std::get<0>(pack) << ", " << std::get<1>(pack) << '\n';
}

static void fun(int &a)
{
	a = 15;
}

int test_tuple_1()
{
{ // std::tuple_element: class template, Class designed to access the type of the Ith element in a tuple.
  // It is a simple class with a single member type, tuple_element::type,
  // defined as an alias of the type of the Ith element in a tuple of type T.
	auto mytuple = std::make_tuple(10, 'a');

	std::tuple_element<0, decltype(mytuple)>::type first = std::get<0>(mytuple);
	std::tuple_element<1, decltype(mytuple)>::type second = std::get<1>(mytuple);

	std::cout << "mytuple contains: " << first << " and " << second << '\n';
}

{ // std::tuple_size: Class template designed to access the number of elements in a tuple
	std::tuple<int, char, double> mytuple(10, 'a', 3.14);

	std::cout << "mytuple has ";
	std::cout << std::tuple_size<decltype(mytuple)>::value;
	std::cout << " elements." << '\n';
}

{ // std::forward_as_tuple: function template, Constructs a tuple object with rvalue references
  // to the elements in args suitable to be forwarded as argument to a function.
	std::string str("John");
	print_pack(std::forward_as_tuple(str + " Smith", 25));
	print_pack(std::forward_as_tuple(str + " Daniels", 22));
}

{ // std::get: funtion template, Returns a reference to the Ith element of tuple tpl.
	std::tuple<int, char> mytuple(10, 'a');

	std::get<0>(mytuple) = 20;

	std::cout << "mytuple contains: ";
	std::cout << std::get<0>(mytuple) << " and " << std::get<1>(mytuple);
	std::cout << std::endl;
}

{ // std::make_tuple: function template, Constructs an object of the appropriate tuple type
  // to contain the elements specified in args
	auto first = std::make_tuple(10, 'a');             // tuple < int, char >

	const int a = 0; int b[3];                         // decayed types:
	auto second = std::make_tuple(a, b);               // tuple < int, int* >

	auto third = std::make_tuple(std::ref(a), "abc");  // tuple < const int&, const char* >

	std::cout << "third contains: " << std::get<0>(third);
	std::cout << " and " << std::get<1>(third);
	std::cout << std::endl;
}

{ // std::tie: function template, Constructs a tuple object whose elements are references
  // to the arguments in args, in the same order
  // std::ignore: object, This object ignores any value assigned to it. It is designed to be used as an
  // argument for tie to indicate that a specific element in a tuple should be ignored.
	int myint;
	char mychar;

	std::tuple<int, float, char> mytuple;

	mytuple = std::make_tuple(10, 2.6, 'a');          // packing values into tuple

	std::tie(myint, std::ignore, mychar) = mytuple;   // unpacking tuple into variables

	std::cout << "myint contains: " << myint << '\n';
	std::cout << "mychar contains: " << mychar << '\n';
}

{ // std::tuple_cat: function template, Constructs an object of the appropriate tuple type
  // to contain a concatenation of the elements of all the tuples in tpls, in the same order
	std::tuple<float, std::string> mytuple(3.14, "pi");
	std::pair<int, char> mypair(10, 'a');

	auto myauto = std::tuple_cat(mytuple, std::tuple<int, char>(mypair));

	std::cout << "myauto contains: " << '\n';
	std::cout << std::get<0>(myauto) << '\n';
	std::cout << std::get<1>(myauto) << '\n';
	std::cout << std::get<2>(myauto) << '\n';
	std::cout << std::get<3>(myauto) << '\n';
}

{ // tuple::tuple: A tuple is an object capable to hold a collection of elements.
	// Each element can be of a different type.
	std::tuple<int, char> foo(10, 'x');
	auto bar = std::make_tuple("test", 3.1, 14, 'y');

	std::get<2>(bar) = 100;                                    // access element

	int myint; char mychar;

	std::tie(myint, mychar) = foo;                            // unpack elements
	std::tie(std::ignore, std::ignore, myint, mychar) = bar;  // unpack (with ignore)

	mychar = std::get<3>(bar);

	std::get<0>(foo) = std::get<2>(bar);
	std::get<1>(foo) = mychar;

	std::cout << "foo contains: ";
	std::cout << std::get<0>(foo) << ' ';
	std::cout << std::get<1>(foo) << '\n';
}

{
	std::tuple<int, char> foo{ 12, 'a' };
	std::cout << std::get<0>(foo) << "\n"; // 12
	fun(std::get<0>(foo));
	std::cout << std::get<0>(foo) << "\n"; // 15
}

	return 0;
}