類模板 std::tuple 是不同類型值的固定大小集合。 它是 std::pair 的泛化。 可以當(dāng)做一個(gè)結(jié)構(gòu)體使用 ,不需要?jiǎng)?chuàng)建結(jié)構(gòu)體就能獲得結(jié)構(gòu)體的特征

std::tuple理論上可以有無數(shù)個(gè)任意類型的成員變量，而std::pair只能是2個(gè)成員，因此在需要保存3個(gè)及以上的數(shù)據(jù)時(shí)就需要使用tuple元組了

直觀感受一下：

#include < iostream >
#include < tuple >
int main(int argc, char **argv) {

  typedef std::tuple< int, double, int, double > Randy;

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

  Randy q1;
  q1 = q0;
  // display contents " 0 1 2 3"
  std::cout < < " " < < std::get< 0 >(q1);
  std::cout < < " " < < std::get< 1 >(q1);
  std::cout < < " " < < std::get< 2 >(q1);
  std::cout < < " " < < std::get< 3 >(q1);
  std::cout < < std::endl;

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

  Randy q3(q0);
  // display contents " 0 1 2 3"
  std::cout < < " " < < std::get< 0 >(q3);
  std::cout < < " " < < std::get< 1 >(q3);
  std::cout < < " " < < std::get< 2 >(q3);
  std::cout < < " " < < std::get< 3 >(q3);
  std::cout < < std::endl;

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

  Randy q4(Randy2(4, 5, 6, 7));
  // display contents " 4 5 6 7"
  std::cout < < " " < < std::get< 0 >(q4);
  std::cout < < " " < < std::get< 1 >(q4);
  std::cout < < " " < < std::get< 2 >(q4);
  std::cout < < " " < < std::get< 3 >(q4);
  std::cout < < std::endl;

  return (0);
}

result:

0 1 2 3
 0 1 2 3
 x 4
 0 1 2 3
 4 5 6 7

成員函數(shù)及非成員函數(shù)

模板參數(shù)

成員函數(shù)

Non-member functions非成員函數(shù)

輔助類

構(gòu)造函數(shù)

#include < iomanip >
#include < iostream >
#include < memory >
#include < string >
#include < tuple >
#include < type_traits >
#include < vector >
 
// 將向量打印到流的輔助函數(shù)
template< class Os, class T >
Os& operator< < (Os& os, std::vector< T > const& v)
{
    os < < '{';
    for (auto i{v.size()}; const T& e : v)
        os < < e < < (--i ? "," : "");
    return os < < '}';
}
 
template< class T >
void print_single(T const& v)
{
    if constexpr (std::is_same_v< T, std::decay_t< std::string >?>)
        std::cout < < std::quoted(v);
    else if constexpr (std::is_same_v< std::decay_t< T >, char >)
        std::cout < < "'" < < v < < "'";
    else
        std::cout < < v;
}
 
// 打印任意大小的元組的輔助函數(shù)
template< class Tuple, std::size_t N >
struct TuplePrinter {
    static void print(const Tuple& t)
    {
        TuplePrinter< Tuple, N-1 >::print(t);
        std::cout < < ", ";
        print_single(std::get< N-1 >(t));
    }
};
 
template< class Tuple >
struct TuplePrinter Tuple, 1 >{
    static void print(const Tuple& t)
    {
        print_single(std::get< 0 >(t));
    }
};
 
template< class... Args >
void print(const std::tuple< Args... >& t)
{
    std::cout < < "(";
    TuplePrinter< decltype(t), sizeof...(Args) >::print(t);
    std::cout < < ")n";
}
// 輔助函數(shù)結(jié)束
 
int main()
{
    std::tuple< int, std::string, double > t1;
    std::cout < < "Value-initialized, t1: "; 
    print(t1);
    
    std::tuple< int, std::string, double > t2{42, "Test", -3.14};
    std::cout < < "Initialized with values, t2: "; 
    print(t2);
    
    std::tuple< char, std::string, int > t3{t2};
    std::cout < < "Implicitly converted, t3: "; 
    print(t3);
    
    std::tuple< int, double > t4{std::make_pair(42, 3.14)};
    std::cout < < "Constructed from a pair, t4: ";
    print(t4);
 
    // 給定的分配器 my_alloc 具有單參數(shù)構(gòu)造函數(shù)
    // my_alloc(int); 使用 my_alloc(1) 在向量中分配 5 個(gè)整數(shù)
    using my_alloc = std::allocator< int >;
    std::vector< int, my_alloc > v { 5, 1, my_alloc{/*1*/} };
    
    // 使用 my_alloc(2) 在元組的向量中分配 5 個(gè)整數(shù)
    std::tuple< int, std::vector< int, my_alloc >, double > t5{
        std::allocator_arg, my_alloc{/*2*/}, 42, v, -3.14};
    std::cout < < "Constructed with allocator, t5: ";
    print(t5);
}

結(jié)果：

Value-initialized, t1: (0, "", 0)
Initialized with values, t2: (42, "Test", -3.14)
Implicitly converted, t3: ('*', "Test", -3)
Constructed from a pair, t4: (42, 3.14)
Constructed with allocator, t5: (42, {1,1,1,1,1}, -3.14)

獲取元祖元素值

#include < tuple >
#include < iostream >
#include < string >
#include < stdexcept >
 
std::tuple< double, char, std::string > get_student(int id)
{
    switch (id)
    {
        case 0: return {2.13, 'A', "Randy Simpson"};
        case 1: return {2.9, 'C', "Milhouse Sesame"};
        case 2: return {1.22, 'D', "Kim Wiggum"};
        case 3: return {0.6, 'F', "SanJie JiYuan"};
    }
 
    throw std::invalid_argument("id");
}
 
int main()
{
    const 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';
 
    const auto student1 = get_student(1);
    std::cout < < "ID: 1, "
              < < "GPA: " < < std::get< double >(student1) < < ", "
              < < "grade: " < < std::get< char >(student1) < < ", "
              < < "name: " < < std::get< std::string >(student1) < < 'n';
 
    double gpa2;
    char grade2;
    std::string name2;
    std::tie(gpa2, grade2, name2) = get_student(2);
    std::cout < < "ID: 2, "
              < < "GPA: " < < gpa2 < < ", "
              < < "grade: " < < grade2 < < ", "
              < < "name: " < < name2 < < 'n';
 
    // C++17 structured binding:
    const auto [ gpa3, grade3, name3 ] = get_student(3);
    std::cout < < "ID: 3, "
              < < "GPA: " < < gpa3 < < ", "
              < < "grade: " < < grade3 < < ", "
              < < "name: " < < name3 < < 'n';
}

結(jié)果：

ID: 0, GPA: 2.13, grade: A, name: Randy Simpson
ID: 1, GPA: 2.9, grade: C, name: Milhouse Sesame
ID: 2, GPA: 1.22, grade: D, name: Kim Wiggum
ID: 3, GPA: 0.6, grade: F, name: SanJie JiYuan

元素個(gè)數(shù)

std::tuple< int, char, double > randy (2, 'san_jie_ji_yuan', 0.13);
 
  std::cout < < std::tuple_size< decltype(randy) >::value;

結(jié)果： 3

元素的類型

std::tuple< std::string, int > tq("Randy", 213);
  
std::tuple_element< 1, decltype(tq) >::type sesames;  

sesames = std::get< 1 >(tq);

std::cout < < "sesames: " < < sesames < < std::endl;

結(jié)果：sesames: 213