C 语言

关注公众号 jb51net

关闭
首页 > 软件编程 > C 语言 > C++11, 14, 17对tuple元素访问

C++11, 14, 17对tuple元素的访问详情

作者:歪锅锅

这篇文章主要介绍了C++11, 14, 17对tuple元素的访问详情,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教

C++11, 14, 17对tuple元素的访问

std::tuple 作为可以存放任意个数,任意类型的元祖被我个人经常使用。

记得以前看侯捷谈到这个数据结构的时候,被他的实现所惊奇,太巧妙地设计。

我自己在使用std::tuple的时候也随着C++版本的更新尝试新的写法,对于元组中元素的获取,我一直觉得很有意思:

比如我有这么一个源文件:

#include <iostream>
#include <tuple>

#define CPP11 (__cplusplus < 201401L)
#define CPP14 (__cplusplus < 201701L and __cplusplus > 201401L)
#define CPP17 (__cplusplus >= 201702L)

class Moo {
  Moo() { ::printf("%s\n", __PRETTY_FUNCTION__); }
  Moo(Moo const &) { ::printf("%s\n", __PRETTY_FUNCTION__); }
  Moo(Moo &&) { ::printf("%s\n", __PRETTY_FUNCTION__); }
  Moo &operator=(Moo const &) noexcept {
    ::printf("%s\n", __PRETTY_FUNCTION__);
    return *this;
  }

  Moo &operator=(Moo &&) noexcept {
    ::printf("%s\n", __PRETTY_FUNCTION__);
    return *this;
  }

  ~Moo() { ::printf("%s\n", __PRETTY_FUNCTION__); }
};

int main() {
  std::cout << "c++ version:" << __cplusplus << std::endl;
  auto &&tp = std::make_tuple<Moo, const char *, int>(Moo(), "hello world", 3);

#if CPP11
  auto &&first = std::get<0>(tp);
  auto &&second = std::get<1>(tp);
  auto &&third = std::get<2>(tp);
#endif

#if CPP14
  auto &&first = std::get<Moo>(tp);
  auto &&second = std::get<const char *>(tp);
  auto &&third = std::get<int>(tp);
#endif

#if CPP17
  auto [a, b, c] = tp;
  auto &[first, second, third] = tp;
#endif

  return 0;
}

Moo类考察当前对象在构造tuple和返回值的过程中经历怎样的人生

std::tuple大总结

C++11引入了一个新的较实用的模板类型,std::tuple,也即是元组。元组是一个固定大小的不同类型(异质,heterogeneous)值的集合,也即它可以同时存放不同类型的数据。

类似于python中用小括号表示的元组类型。C++已有的std::pair类型类似于一个二元组,可看作是std::tuple的一个特例,std::tuple也可看作是std::pair的泛化。std::pair的长度限制为2,而std::tuple的元素个数为0~任意个。

元组的使用

典型使用

创建和初始化

{
    std::tuple<int, double, std::string> first;    // 创建一个空的元组,需要指定元组元素的数据类型,调用各个成员的默认构造函数进行初始化。
    std::tuple<int, double, std::string> second(first);  // 拷贝构造
    std::tuple<int, char> third(10, 'a');        // 创建并初始化,使用小括号初始化
    std::tuple<int, std::string, double> fourth{42, "Test", -3.14};  // 创建并初始化,使用新的大括号初始化列表方式初始化
    std::tuple<int, char> fifth(std::make_tuple(20, 'b'));     // 移动构造,使用模板库的make_tuple
    first = std::make_tuple(1, 3.14, "tuple");       // 移动赋值
    int i_third = 3;
    std::tuple<int&> sixth(std::ref(i_third));   // 创建一个元组,元组的元素可以被引用
} 

元组的访问和修改 

std::get<N>()

{
    int n = 1;
    auto t = std::make_tuple(10, "Test", 3.14, std::ref(n), n);
    // get尖括号中的值必须是一个整型常量表达式。从0开始计数,意味着get<0>是第一个成员。
    std::cout << "The value of t is "  << "("
               << std::get<0>(t) << ", " << std::get<1>(t) << ", "
               << std::get<2>(t) << ", " << std::get<3>(t) << ", "
               << std::get<4>(t) << ")\n";
    // 由于get返回指定元素的引用,所以可用来修改指定位置的元素的值。此处因为第4个元素是引用类型,所以被引用的值也会改变
    std::get<3>(t) = 9;
    std::cout << n << std::endl;
}

元组的元素个数

使用std::tuple_size<>()

{
    std::tuple<char, int, long, std::string> first('A', 2, 3, "4");
    int i_count = std::tuple_size<decltype(first)>::value;  // 使用std::tuple_size计算元组个数
    std::cout << "the number of elements of a tuple:" << i_count << "\n";
}

元组的解包

std::tie() 元组包含一个或者多个元素,使用std::tie解包: 首先需要定义对应元素的变量,再使用tie。

{ // 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_element。 语法: std::tuple_element<index, tuple>。

{
    std::tuple<int, std::string> third(9, std::string("ABC"));
    
    // 得到元组第1个元素的类型,用元组第一个元素的类型声明一个变量
    std::tuple_element<1, decltype(third)>::type val_1;
    
    // 获取元组的第一个元素的值
    val_1 = std::get<1>(third);
    std::cout << "val_1 = " << val_1.c_str() << "\n";
}

元组的拼接

使用 std::tuple_cat 执行拼接

{
    std::tuple<char, int, double> first('A', 1, 2.2f);
    // 组合到一起, 使用auto, 自动推导
    auto second = std::tuple_cat(first, std::make_tuple('B', std::string("-=+")));
    // 组合到一起,可以知道每一个元素的数据类型时什么 与 auto推导效果一样
    std::tuple<char, int, double, char, std::string> third = std::tuple_cat(first, std::make_tuple('B', std::string("-=+")));
    // 输出合并后的元组内容
    int index = 0;
    std::cout << index++ << " = " << std::get<0>(second) << "\n";  // 0 = A
    std::cout << index++ << " = " << std::get<1>(second) << "\n";  // 1 = 1 
    std::cout << index++ << " = " << std::get<2>(second) << "\n";  //  2 = 2.2
    std::cout << index++ << " = " << std::get<3>(second) << "\n";  // 3 = B
    std::cout << index++ << " = " << std::get<4>(second).c_str() << "\n"; // 4 = -=+
}

元组的遍历

元组没用提供operator []重载,遍历起来较为麻烦,需要为其单独提供遍历模板函数 

以上为个人经验,希望能给大家一个参考,也希望大家多多支持脚本之家。

您可能感兴趣的文章:
阅读全文