c++之元组std::tuple常见用法

元组，c++11中引入的新的类型，可类比std::pair。但是std::pair只能支持两个元素。理论上，元组支持0~任意个元素。

　　本文演示环境： VS2015 up3

0、头文件

#include <tuple>

1、创建和初始化

　　1.1、创建一个空的元组，创建时，需要指定元组的数据类型。

std::tuple<int, float, double, long, long long> first;

　　1.2 、创建一个元组并初始化元组。　　

1     std::string str_second_1("_1");

2     std::string str_second_2("_2");

3

4     // 指定了元素类型为引用 和 std::string, 下面两种方式都是可以的，只不过第二个参数不同而已

5     std::tuple<std::string, std::string> second_1(str_second_1, std::string("_2"));

6     std::tuple<std::string, std::string> second_2(str_second_1, str_second_2);

　　1.3、创建一个元素是引用的元组

1     //3、创建一个元组，元组的元素可以被引用, 这里以 int 为例

2     int i_third = 3;

3     std::tuple<int&> third(std::ref(i_third));

　　1.4、使用make_tuple创建元组

1     int i_fourth_1 = 4;

2     int i_fourth_2 = 44;

3     // 下面的两种方式都可以

4     std::tuple<int, int> forth_1    = std::make_tuple(i_fourth_1, i_fourth_2);

5     auto forth_2                    = std::make_tuple(i_fourth_1, i_fourth_2);

　　1.5、创建一个类型为引用的元组，对元组的修改。这里以 std::string为例

 1     std::string str_five_1("five_1");

 2     // 输出原址值

 3     std::cout << "str_five_1 = " << str_five_1.c_str() << "\n";

 4

 5     std::tuple<std::string&, int> five(str_five_1, 5);

 6     // 通过元组 对第一个元素的修改，str_five_1的值也会跟着修改，因为元组的第一个元素类型为引用。

 7     // 使用get访问元组的第一个元素

 8     std::get<0>(five) = "five_2";

 9

10     // 输出的将是： five_2

11     std::cout << "str_five_1 = " << str_five_1.c_str() << "\n";

　　输出结果（VS2015 up3输出）：

2、计算元组的元素个数

　　需要函数： std::tuple_size。下面是一个例子，

1     std::tuple<char, int, long, std::string> first('A', 2, 3, "4");

2         // 使用std::tuple_size计算元组个数

3         int i_count = std::tuple_size<decltype(first)>::value;

4         std::cout << "元组个数=" << i_count << "\n";

　　输出结果：

3、访问元素

　　访问元组的元素，需要函数： std::get<index>(obj)。其中：【index】是元组中元素的下标，0 ，1 ， 2， 3， 4，.... 【obj】-元组变量。　　

　　一个例子：

1 std::tuple<char, int, long, std::string> second('A', 2, 3, "4");

2 int index = 0;

3 std::cout << index++ << " = " << std::get<0>(second) << "\n";

4 std::cout << index++ << " = " << std::get<1>(second) << "\n";

5 std::cout << index++ << " = " << std::get<2>(second) << "\n";

6 std::cout << index++ << " = " << std::get<3>(second).c_str() << "\n";

　　输出结果：

　　【注意】元组不支持迭代访问，且只能通过索引（或者tie解包：将元组的中每一个元素提取到指定变量中）访问，且索引不能动态传入。上面的代码中，索引都是在编译器编译期间就确定了。下面的演示代码将会在编译期间出错。

for (int i = 0; i < 3; i++)

        std::cout << index++ << " = " << std::get<i>(second) << "\n";　　// 无法通过编译

4、获取元素的类型

　　获取元组中某个元素的数据类型，需要用到另外一个类型： std::tuple_element 。语法： std::tuple_element<index, tuple> 。【index】-元组中元素的索引，【tuple】哪一个元组

　　一个例子：

1 std::tuple<int, std::string> third(9, std::string("ABC"));

2

3 // 得到元组第1个元素的类型，用元组第一个元素的类型声明一个变量

4 std::tuple_element<1, decltype(third)>::type val_1;

5

6 // 获取元组的第一个元素的值

7 val_1 = std::get<1>(third);

8 std::cout << "val_1 = " << val_1.c_str() << "\n";

　　输出结果：

　　　用获取元组第一个元素的类型声明了一个变量，再对变量赋值。

5、使用 std::tie解包

　　元组，可以看作一个包，类比结构体。需要访问元组的元素时，2 种方法： A、索引访问，B、std::tie 。

　　元组包含一个或者多个元素，使用std::tie解包：首先需要定义对应元素的变量，再使用tie。比如，元素第0个元素的类型时 char, 第1个元素类型时int, 那么，需要定义一个 char的变量和int的变量，用来储存解包元素的结果。

　　一个例子：

 1 std::tuple<char, int, long, std::string> fourth('A', 2, 3, "4");

 2

 3 // 定义变量，保存解包结果

 4 char tuple_0    = '0';

 5 int tuple_1        = 0;

 6 long tuple_2    = 0;

 7 std::string tuple_3("");

 8

 9 // 使用std::tie, 依次传入对应的解包变量

10 std::tie(tuple_0, tuple_1, tuple_2, tuple_3) = fourth;

11

12 // 输出解包结果

13 std::cout << "tuple_0 = " << tuple_0 << "\n";

14 std::cout << "tuple_1 = " << tuple_1 << "\n";

15 std::cout << "tuple_2 = " << tuple_2 << "\n";

16 std::cout << "tuple_3 = " << tuple_3.c_str() << "\n";

　　输出结果：

　　说到 std::tie , 看下 VS2015 up3中的定义：

1 template<class... _Types> inline

2     constexpr tuple<_Types&...>

3         tie(_Types&... _Args) _NOEXCEPT

4     {    // make tuple from elements

5     typedef tuple<_Types&...> _Ttype;

6     return (_Ttype(_Args...));

7     }

　　接着 std::tie 解包。如果一个元组，只需要取出其中特定位置上的元素，不用把每一个元素取出来，怎么做？

　　比如：只要索引为偶数的元素。

　　元组提供了类似占位符的功能： std::ignore 。满足上面的需求，只需要在索引为奇数的位置填上 std::ignore 。一个例子：

 1 std::tuple<char, int, long, std::string> fourth('A', 2, 3, "4");

 2

 3 // 定义变量，保存解包结果

 4 char tuple_0    = '0';

 5 int tuple_1        = 0;

 6 long tuple_2    = 0;

 7 std::string tuple_3("");

 8

 9 // 使用占位符

10 std::tie(tuple_0, std::ignore, tuple_2, std::ignore) = fourth;

11

12 // 输出解包结果

13 std::cout << "tuple_0 = " << tuple_0 << "\n";

14 std::cout << "tuple_1 = " << tuple_1 << "\n";

15 std::cout << "tuple_2 = " << tuple_2 << "\n";

16 std::cout << "tuple_3 = " << tuple_3.c_str() << "\n";

　　输出结果：

6、元组连接（拼接）

　　使用 std::tuple_cat 执行拼接

　　一个例子：

 1 std::tuple<char, int, double> first('A', 1, 2.2f);

 2

 3 // 组合到一起, 使用auto， 自动推导

 4 auto second = std::tuple_cat(first, std::make_tuple('B', std::string("-=+")));

 5 // 组合到一起，可以知道每一个元素的数据类型时什么 与 auto推导效果一样

 6 std::tuple<char, int, double, char, std::string> third = std::tuple_cat(first, std::make_tuple('B', std::string("-=+")));

 7

 8 // 输出合并后的元组内容

 9 int index = 0;

10 std::cout << index++ << " = " << std::get<0>(second) << "\n";

11 std::cout << index++ << " = " << std::get<1>(second) << "\n";

12 std::cout << index++ << " = " << std::get<2>(second) << "\n";

13

14 std::cout << index++ << " = " << std::get<3>(second) << "\n";

15 std::cout << index++ << " = " << std::get<4>(second).c_str() << "\n";

　　输出结果：

7、遍历

　　这里将采用的时递归遍历，需要注意，考虑爆栈的情况。其实，tuple也是基于模板的STL容器。因为其可以容纳多个参数，且每个参数类型可不相同，遍历输出则涉及到参数展开的情况，这里以递归的方式实现遍历，核心代码：

 1 template<typename Tuple, size_t N>

 2 struct tuple_show

 3 {

 4     static void show(const Tuple &t, std::ostream& os)

 5     {

 6         tuple_show<Tuple, N - 1>::show(t, os);

 7         os << ", " << std::get<N - 1>(t);

 8     }

 9 };

10

11

12 // 偏特性，可以理解为递归的终止

13 template<typename Tuple>

14 struct tuple_show < Tuple, 1>

15 {

16     static void show(const Tuple &t, std::ostream &os)

17     {

18         os <<  std::get<0>(t);

19     }

20 };

21

22

23

24 // 自己写个函数，调用上面的递归展开，

25 template<typename... Args>

26 std::ostream& operator << (std::ostream &os, const std::tuple<Args...>& t)

27 {

28     os << "[";

29     tuple_show<decltype(t), sizeof...(Args)>::show(t, os);

30     os << "]";

31

32     return os;

33 }

　　调用示例：

1     auto t1 = std::make_tuple(1, 'A', "-=+", 2);

2     std::cout << t1;

　　输出结果：

巴特西

c++之元组std::tuple常见用法

0、头文件

1、创建和初始化

3、访问元素

4、获取元素的类型

5、使用 std::tie解包

6、元组连接（拼接）

7、遍历

最新文章

热门文章