tuple

C++11 STL

---

tuple

template <class... Types> class tuple;

　　tuple元组定义了一个有固定数目元素的容器,其中的每个元素类型都可以不相同,这与其他容器有着本质的区别
　　

tuple::tuple

constexpr tuple();
tuple (const tuple& tpl) = default;
tuple (tuple&& tpl) = default;

template <class... UTypes>
    tuple (const tuple<UTypes...>& tpl);
template <class... UTypes>
    tuple (tuple<UTypes...>&& tpl);

explicit tuple (const Types&... elems);
template <class... UTypes>
    explicit tuple (UTypes&&... elems);

template <class U1, class U2>
    tuple (const pair<U1,U2>& pr);
template <class U1, class U2>
    tuple (pair<U1,U2>&& pr);

std::tuple是简单结构体的一个替换品，如

struct Person{
    char name[20];
    int age;
    int id;
};
typedef std::tuple<char*,int ,int> Person;

example

// tuple constructors
#include <iostream>     // std::cout
#include <utility>      // std::make_pair
#include <tuple>        // std::tuple, std::make_tuple, std::get
int main ()
{
  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';
  return 0;
}

make_tuple

template<class... Types>
    tuple<VTypes...> make_tuple (Types&&... args);

make_tuple与构造函数无异,就是简单一些，不需要写模版参数，利用auto以及类型推导即可。

#include <iostream>
#include <tuple>
#include <functional>
int main()
{
  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;
  return 0;
}

get

template <size_t I, class... Types>
    typename tuple_element< I, tuple<Types...> >::type& get(tuple<Types...>& tpl) noexcept;
template <size_t I, class... Types>
    typename tuple_element< I, tuple<Types...> >::type&& get(tuple<Types...>&& tpl) noexcept;
template <size_t I, class... Types>
    typename tuple_element< I, tuple<Types...> >::type const& get(const tuple<Types...>& tpl) noexcept;

　　获取tuple元素或者元素的引用，然后改变元素的值
example

#include <iostream>
#include <tuple>
int main ()
{
  std::tuple<int,char> mytuple (10,'a');
  std::get<0>(mytuple) = 20;
  std::cout << std::get<0>(mytuple) << " and " << std::get<1>(mytuple)<<std::endl;
  auto &r = std::get<0>(mytuple);
  r = 30;
  std::cout << std::get<0>(mytuple) << " and " << std::get<1>(mytuple)<<std::endl;
  auto a = std::get<0>(mytuple);
  a = 40;
  std::cout << std::get<0>(mytuple) << " and " << std::get<1>(mytuple)<<std::endl;
  return 0;
}

tie

template<class... Types>
tuple<Types&...> tie (Types&... args) noexcept;

#include <iostream>     // std::cout
#include <tuple>        // std::tuple, std::make_tuple, std::tie
int main ()
{
  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
  myint += 1;
  std::cout << "myint contains: " << myint << '\n';
  std::cout << "mychar contains: " << mychar << '\n';
  std::tie (myint, std::ignore, mychar) = mytuple;   // unpacking tuple into variables
  std::cout << "myint contains: " << myint << '\n';
  return 0;
}

　　通过tie解包后，mytuple中三个值会自动赋值给三个变量。
解包时，我们如果只想解某个位置的值时，可以用std::ignore占位符来表示不解某个位置的值。tie解包的解出来的是引用，可以通过引用改变tuple元素的值。

tuple_cat

template <class... Tuples>
    tuple<CTypes...> tuple_cat (Tuples&&... tpls);//Concatenate tuples

example

// tuple_cat example
#include <iostream>     // std::cout
#include <utility>      // std::pair
#include <string>       // std::string
#include <tuple>        // std::tuple, std::tuple_cat, std::get
int main ()
{
  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';
  return 0;
}