C++之std::tuple(一) : 使用精讲(全)

相关系列文章

C++三剑客之std::any(一) : 使用

C++之std::tuple(一) : 使用精讲(全)

C++三剑客之std::variant(一) : 使用

C++三剑客之std::variant(二)：深入剖析

深入理解可变参数(va_list、std::initializer_list和可变参数模版)

std::apply源码分析

目录

1.简介

2.std::ignore介绍

3.创建元组

3.1.直接初始化方式

3.2.使用花括号初始化列表方式（C++11及以上版本）

3.3.make_tuple方式

3.4.使用std::tie()函数方式

4.元素访问

4.1.std::get()方式

4.2.使用结构化绑定（C++17及以上）

4.3.递归遍历元素

4.4.std::apply方式(C++17及以上)

5.获取std::tuple的size

6.获取元组中的元素类型

7.std::forward_as_tuple

8.std::tuple_cat

9.std::swap

10.std::make_from_tuple

11.总结

1.简介

        C++11之后引入了std::tuple，俗称元组，元组(tuple)是一种用于组合多个不同类型的值的数据结构。元组可以将不同类型的数据打包在一起，类似于一个容器，可以按照索引顺序访问其中的元素。元组的大小在编译时确定，不支持动态添加或移除元素。std::tuple的定义如下：

  1. template<class... Types>
  2. class tuple;

        std::tuple类似互C语言的结构体，不需要创建结构体而又有结构体的特征，在某些情况下可以取代结构体而使得程序更加简洁，直观。std::tuple理论上可以定义无数多个不同类型的成员变量。特别是你需要在函数之间返回多个值时，或者需要一次性处理多个相关值时，使用元组可以简化代码并提高可读性。

2.std::ignore介绍

在标头  定义，任何值均可赋给而无效果的未指定类型的对象。目的是令 std::tie 在解包 std::tuple 时作为不使用的参数的占位符使用。例如：解包 set.insert() 所返回的 pair ，但只保存布尔值。

  1. #include 
  2. #include 
  3. #include 
  4. #include 
  5.  
  6. int main()
  7. {
  8.     std::set set_of_str;
  9.     bool inserted = false;
  10.     std::tie(std::ignore, inserted) = set_of_str.insert("Test");
  11.     if (inserted) {
  12.         std::cout << "Value was inserted successfully\n";
  13.     }
  14. }

输出：Value was inserted successfully

3.创建元组

3.1.直接初始化方式

  1. //显示初始化
  2. std::tuple<bool, int, double, std::string>  a(true, 1, 3.0, "1112222");

3.2.使用花括号初始化列表方式（C++11及以上版本）

  1. //显示初始化
  2. std::tuple<bool, int, double, std::string>  a{true, 1, 3.0, "1112222"};

3.3.make_tuple方式

  1. //显示初始化
  2. std::tuple<bool, int, double, std::string> a = make_tuple(true, 1, 3.0, "1112222");
  3.  
  4. //隐式初始化
  5. auto b = make_tuple(true, 1, 3.0, "1112222");

3.4.使用std::tie()函数方式

 std::tie定义为：

  1. template<class... Types>
  2. constexpr tuple tie (Types&... args) noexcept;
std::tie生成一个tuple,此tuple包含的分量全部为实参的引用，与make_tuple完全相反。主要用于从tuple中提取数据。例如：

  1. bool myBool;
  2. int myInt;
  3. double myDouble;
  4. std::string myString;
  5.  
  6. std::tie(myBool, myInt, myDouble, myString) = std::make_tuple(true, 1, 3.0, "1112222");

如果是要忽略某个特定的元素，还可以使用第2章节的std::ignore来占位，例如：

  1. bool myBool;
  2. std::string myString;
  3.  
  4. std::tie(myBool, std::ignore, std::ignore, myString) = std::make_tuple(true, 1, 3.0, "1112222");

4.元素访问

4.1.std::get()方式

使用std::get来访问std::tuple特定的元素，如：

  1. std::tuple<bool, int, std::string> a(true, 0, "sfsfs");
  2. bool b = std::get<0>(a);
  3. int  c = std::get<1>(a);
  4. std::string d = std::get<2>(a);
  5.  
  6. std::get<0>(a) = false;
  7. std::get<2>(a) = "s344242";

4.2.使用结构化绑定（C++17及以上）

在C++17及以上版本中，还可以使用结构化绑定 (structured bindings) 的方式来创建和访问元组，可以更方便地访问和操作元组中的元素。结构化绑定允许直接从元组中提取元素并赋值给相应的变量。例如：

  1. std::tuple<bool, int, std::string> myTuple(true, false, "Hello");
  2. auto [a, b, c] = myTuple;

这将自动创建变量a、b和c，并将元组中相应位置的值赋给它们。

注意：

元组是不可变的（immutable）一旦创建就不能更改其元素的值。但是，可以通过解构赋值或使用std::get(tuple)来获取元组中的值，并将新的值赋给它们，从而修改元组中的值。

std::tuple不支持迭代器，获取元素的值时只能通过元素索引或tie解包。给定的索引必须是在编译期间就已经确定的，不能在运行期间动态传递，否则会产生编译错误

4.3.递归遍历元素

        由于 tuple 自身的原因，无法直接遍历，而 get 中 index 必须为运行前设置好的常数
所以 tuple 的遍历需要我们手写，代码如下:

  1. template<class Tuple, std::size_t N>
  2. struct VisitTuple {
  3.     static void Visit(const Tuple& value) {
  4.         VisitTuple1>::Visit(value);
  5.         std::cout << ' ' << std::get1>(value);
  6.         return void();
  7.     }
  8. };
  9.  
  10. template<class Tuple>
  11. struct VisitTuple1> {
  12.     static void Visit(const Tuple& value) {
  13.         std::cout << std::get<0>(value);
  14.         return void();
  15.     }
  16. };
  17.  
  18. template<class... Args>
  19. void TupleVisit(const std::tuple& value) {
  20.     VisitTuple<decltype(value), sizeof ...(Args)>::Visit(value);
  21. }

4.4.std::apply方式(C++17及以上)

利用可变参数的折叠表达式规则来访问std::tuple的元素，例如：

  1. #include 
  2. #include 
  3. #include 
  4.  
  5. int add(int first, int second) { return first + second; }
  6.  
  7. template<typename T>
  8. T add_generic(T first, T second) { return first + second; }
  9.  
  10. auto add_lambda = [](auto first, auto second) { return first + second; };
  11.  
  12. template<typename... Ts>
  13. std::ostream& operator<<(std::ostream& os, std::tuple const& theTuple)
  14. {
  15.     std::apply
  16.     (
  17.         [&os](Ts const&... tupleArgs)
  18.         {
  19.             os << '[';
  20.             std::size_t n{0};
  21.             ((os << tupleArgs << (++n != sizeof...(Ts) ? ", " : "")), ...);
  22.             os << ']';
  23.         }, theTuple
  24.     );
  25.     return os;
  26. }
  27.  
  28. int main()
  29. {
  30.     // OK
  31.     std::cout << std::apply(add, std::pair(1, 2)) << '\n';
  32.  
  33.     // 错误：无法推导函数类型
  34.     // std::cout << std::apply(add_generic, std::make_pair(2.0f, 3.0f)) << '\n'; 
  35.  
  36.     // OK
  37.     std::cout << std::apply(add_lambda, std::pair(2.0f, 3.0f)) << '\n'; 
  38.  
  39.     // 进阶示例
  40.     std::tuple myTuple(25, "Hello", 9.31f, 'c');
  41.     std::cout << myTuple << '\n';
  42. }

输出：

  1. 3
  2. 5
  3. [25, Hello, 9.31, c]

        上面语句((os << tupleArgs << (++n != sizeof...(Ts) ? ", " : "")), ...);利用了C++17的折叠表达式，折叠表达式是C++17新引进的语法特性。使用折叠表达式可以简化对C++11中引入的参数包的处理，从而在某些情况下避免使用递归。如果有不是很明白的地方，可参考我的博客深入理解可变参数(va_list、std::initializer_list和可变参数模版)-CSDN博客

        关于std::applay的使用有不明白的地方，可以参考我的博客std::apply源码分析-CSDN博客

5.获取std::tuple的size

std::tuple_size的定义如下：

  1. template< class... Types >
  2. struct tuple_size< std::tuple >
  3.     : std::integral_constantsize_t, sizeof...(Types)> { };

提供对 tuple 中元素数量的访问，作为编译时常量表达式，计算std::tuple的大小。例如：

  1. #include 
  2. #include 
  3.  
  4. template <class T>
  5. void test(T value)
  6. {
  7.     int a[std::tuple_size_v]; // 能用于编译时
  8.  
  9.     std::cout << std::tuple_size{} << ' ' // 或运行时
  10.               << sizeof a << ' ' 
  11.               << sizeof value << '\n';
  12. }
  13.  
  14. int main()
  15. {
  16.     test(std::make_tuple(1, 2, 3.14));
  17. }

可能的输出：3 12 16

6.获取元组中的元素类型

std::tuple_element定义如下：

  1. template< std::size_t I, class... Types >
  2. class tuple_element< I, tuple >;

可以使用std::tuple_element::type来获取元组中特定索引位置的元素类型。

  1. #include 
  2. #include 
  3.  
  4. template <class... Args>
  5. struct type_list
  6. {
  7.    template size_t N>
  8.    using type = typename std::tuple_element>::type;
  9. };
  10.  
  11. int main()
  12. {
  13.    std::cout << std::boolalpha;
  14.    type_list<int, char, bool>::type<2> x = true;
  15.    std::cout << x << '\n';
  16. }

输出：true

7.std::forward_as_tuple

定义如下：

  1. template< class... Types >
  2. tuple forward_as_tuple( Types&&... args ) noexcept;
  3. template< class... Types >
  4. constexpr tuple forward_as_tuple( Types&&... args ) noexcept;

用于接受右值引用数据生成 tuple, 与 std::make_tuple 不同的是它的右值是引用的，当修改其值的时候，原来赋值所用的右值也将修改，实质上就是赋予了它地址。同std::tie一样，也是生成一个全是引用的tuple,不过std::tie只接受左值，而std::forward_as_tuple左值、右值都接受。主要是用于不损失类型属性的转发数据。

注意此处 tuple 内的类型应为引用，否则相当于 std::make_tuple。例如：

  1. signed main(int argc, char *argv[]) {
  2.     int a = 123, c = 456;
  3.     float b = 33.f, d = .155;
  4.  
  5.     std::tuple<int&, float&, int&, float&> tu = std::forward_as_tuple(a,b,c,d);
  6.  
  7.     std::get<0> (tu) = 2;
  8.     std::get<1> (tu) = 4.5f;
  9.     std::get<2> (tu) = 234;
  10.     std::get<3> (tu) = 22.f;
  11.  
  12.     std::cout << a << std::endl; // 2
  13.     std::cout << b << std::endl; // 4.5
  14.     std::cout << c << std::endl; // 234
  15.     std::cout << d << std::endl; // 22
  16.     return 0;
  17. }

注意：若参数是临时量，则 forward_as_tuple 不延续其生存期；必须在完整表达式结尾前使用它们。

8.std::tuple_cat

        此函数接受多个tuple作为参数，然后返回一个tuple。返回的这个tuple将tuple_cat的参数中的tuple的所有元素按所属的tuple在参数中的顺序以及其在tuple中的顺序排列成一个新的tuple。新tuple中元素的类型与参数中的tuple中的元素的类型完全一致。例如：

  1. #include 
  2. #include 
  3. #include 
  4.  
  5. // 打印任何大小 tuple 的辅助函数
  6. template<class Tuple, std::size_t N>
  7. struct TuplePrinter
  8. {
  9.     static void print(const Tuple& t)
  10.     {
  11.         TuplePrinter1>::print(t);
  12.         std::cout << ", " << std::get-1>(t);
  13.     }
  14. };
  15.  
  16. template<class Tuple>
  17. struct TuplePrinter1>
  18. {
  19.     static void print(const Tuple& t) 
  20.     {
  21.         std::cout << std::get<0>(t);
  22.     }
  23. };
  24.  
  25. template<class... Args>
  26. void print(const std::tuple& t) 
  27. {
  28.     std::cout << "(";
  29.     TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
  30.     std::cout << ")\n";
  31. }
  32. // 辅助函数结束
  33.  
  34. int main()
  35. {
  36.     std::tuple<int, std::string, float> t1(10, "Test", 3.14);
  37.     int n = 7;
  38.     auto t2 = std::tuple_cat(t1, std::make_tuple("Foo", "bar"), t1, std::tie(n));
  39.     n = 10;
  40.     print(t2);
  41. }

输出：(10, Test, 3.14, Foo, bar, 10, Test, 3.14, 10)

9.std::swap

交换两个std::tuple的内容，前提是两个std::tuple的大小和元素类型必须相同，例如：

  1. std::tuple<int, double, char> a1;
  2. std::tuple<int, double, char> a2;
  3. std::tuple<unsigned int, double, char> a3;
  4. std::tuple<int, std::string, char> a4;
  5. std::tuple<int, double, char, std::string> a5;
  6. a1.swap(a2); //OK
  7. a2.swap(a3); //编译出现error
  8. a3.swap(a4);//编译出现error
  9. a4.swap(a5);//编译出现error

上面a1和a2的大小和元素类型都相同，因此可以交换。a2和a3、a3和a4、a4和a5类型不相同，因此不能交换。我们再看一个std::tuple交换的例子：

  1. #include 
  2. #include 
  3. #include 
  4.  
  5. int main()
  6. {
  7.     std::tuple<int, std::string, float>
  8.                       p1{42, "ABCD", 2.71},
  9.                       p2;
  10.     p2 = std::make_tuple(10, "1234", 3.14);
  11.  
  12.     auto print_p1_p2 = [&](auto rem) {
  13.         std::cout << rem
  14.                   << "p1 = {" << std::get<0>(p1)
  15.                   << ", "     << std::get<1>(p1)
  16.                   << ", "     << std::get<2>(p1) << "}, "
  17.                   << "p2 = {" << std::get<0>(p2)
  18.                   << ", "     << std::get<1>(p2)
  19.                   << ", "     << std::get<2>(p2) << "}\n";
  20.     };
  21.  
  22.     print_p1_p2("Before p1.swap(p2): ");
  23.     p1.swap(p2);
  24.     print_p1_p2("After  p1.swap(p2): ");
  25.     swap(p1, p2);
  26.     print_p1_p2("After swap(p1, p2): ");
  27. }

输出：

  1. Before p1.swap(p2): p1 = {42, ABCD, 2.71}, p2 = {10, 1234, 3.14}
  2. After  p1.swap(p2): p1 = {10, 1234, 3.14}, p2 = {42, ABCD, 2.71}
  3. After swap(p1, p2): p1 = {42, ABCD, 2.71}, p2 = {10, 1234, 3.14}

10.std::make_from_tuple

std::make_from_tuple是以元组std::tuple的元素作为构造函数的参数构造别的类型对象，如下例子：

  1. #include 
  2. #include 
  3.  
  4. struct Foo
  5. {
  6.     Foo(int first, float second, int third)
  7.     {
  8.         std::cout << first << ", " << second << ", " << third << "\n";
  9.     }
  10. };
  11.  
  12. int main()
  13. {
  14.     auto tuple = std::make_tuple(42, 3.14f, 0);
  15.     std::make_from_tuple(std::move(tuple));
  16. }

输出：42, 3.14, 0

11.总结

std::tuple 是一种重要的数据结构，可以用于在函数参数之间传递数据，也可以作为函数的返回值。在实际项目中，我们可以灵活地使用 std::tuple，以简化代码，提高程序的性能。

后面我们将继续通过分析std::tuple源码的方式来更深层次讲解它的实现原理，值得期待哦。。。

参考：std::apply源码分析

注：本文转载自blog.csdn.net的流星雨爱编程的文章"https://blog.csdn.net/haokan123456789/article/details/136006995"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！