Tuples and std::tuple

We can think of a std::tuple as a simple extension of a std::pair. Whilst a pair can hold two objects, a tuple can hold any number of objects. And, like a pair, these objects can have different types.

The std::tuple class is available from the <tuple> header. Once included, we can then create a tuple in the usual way. We pass the types of our objects as template parameters, and their values as constructor parameters:

1#include <tuple>
2
3std::tuple<int, float, bool> MyTuple{
4  42, 3.14f, true
5};
6

When initializing the tuple with values, we can omit the template types, allowing the compiler to deduce them using class template argument deduction (CTAD)

1#include <tuple>
2
3std::tuple MyTuple{42, 3.14f, true};
4

The std::make_tuple function also allows tuples to be constructed with deduced types:

1#include <tuple>
2
3void HandleTuple(
4  std::tuple<int, float, bool> Object){
5  // ...
6}
7
8int main(){
9  HandleTuple(std::make_tuple(42, 3.14f, true));
10}
11

This function was introduced to remove the need to specify types, but is less relevant now that CTAD provides the same convenience as a native feature of the language.

Tuple Member Access

Access to objects within a std::tuple is typically done through the std::get template function. We pass the index as a template parameter, and the tuple as an argument:

1#include <tuple>
2#include <iostream>
3
4int main(){
5  std::tuple MyTuple{42, 3.14f, true};
6
7  std::cout << std::get<0>(MyTuple) << ", ";
8  std::cout << std::get<1>(MyTuple) << ", ";
9  std::cout << std::get<2>(MyTuple);
10}
11

142, 3.14, 1
2

The std::get function the element by reference, allowing it to be updated:

1#include <tuple>
2#include <iostream>
3
4int main(){
5  std::tuple MyTuple{42, 3.14f, true};
6
7  std::cout << "First element: "
8    << std::get<0>(MyTuple);
9
10  std::get<0>(MyTuple) = 5;
11
12  std::cout << "\nNew first element: "
13    << std::get<0>(MyTuple);
14}
15

1First element: 42
2New first element: 5
3

We can also pass a type as the template parameter to std::get. This retrieves the element within the tuple that has that type:

1#include <tuple>
2#include <iostream>
3
4int main(){
5  std::tuple MyTuple{42, 3.14f, true};
6
7  std::cout << std::get<float>(MyTuple);
8}
9

13.14
2

This assumes the tuple has exactly one element of that type. If this is not the case, we will get a compilation error.

Structured Binding and std::tie

Similar to pairs, we can unpack tuple objects to dedicated variables using structured binding:

1#include <tuple>
2#include <iostream>
3
4int main(){
5  std::tuple MyTuple{42, 3.14, "Hello"};
6
7  auto [a, b, c]{MyTuple};
8
9  std::cout << a << ", " << b << ", " << c;
10}
11

142, 3.14, Hello
2

When the variables we want to use have already been declared, we can use std::tie to update them. Here, we reuse our a, b, and c variables to store new values:

1#include <tuple>
2#include <iostream>
3
4int main(){
5  using std::cout, std::tuple;
6
7  tuple MyTuple{42, 3.14, true};
8  auto [a, b, c]{MyTuple};
9  cout << a << ", " << b << ", " << c;
10
11  tuple AnotherTuple{100, 9.8, false};
12  std::tie(a, b, c) = AnotherTuple;
13  cout << '\n' << a << ", " << b << ", " << c;
14}
15

142, 3.14, 1
2100, 9.8, 0
3

When using std::tie, we can pass std::ignore in any position to skip over that element in the tuple. Below, we skip over the middle element, only updating a and c:

1#include <tuple>
2#include <iostream>
3
4int main(){
5  using std::cout, std::tuple, std::ignore;
6
7  tuple MyTuple{42, 3.14, true};
8  auto [a, b, c]{MyTuple};
9  cout << a << ", " << b << ", " << c;
10
11  tuple AnotherTuple{100, 9.8, false};
12  std::tie(a, ignore, c) = AnotherTuple;
13  cout << '\n' << a << ", " << b << ", " << c;
14}
15

142, 3.14, 1
2100, 3.14, 0
3

Tuple Size

Similar to std::array, tuples have a fixed, static size, specified at compile time. We can get the size of a tuple by passing its type to the std::tuple_size type trait. Usually, this is done using the shorthand std::tuple_size_v syntax:

1#include <tuple>
2#include <iostream>
3
4template <typename T>
5void HandleTuple(T Tuple){
6  std::cout << "Tuple size: "
7    << std::tuple_size_v<T>;
8}
9
10int main(){
11  HandleTuple(std::tuple{42, 3.14, true});
12}
13

1Tuple size: 3
2

We have a dedicated lesson on type traits earlier in the course

Type Traits

A detailed and practical tutorial for type traits in modern C++ covering how we can use them, and examples of the most common use cases

Tuple Element Type

The std::tuple_element type trait allows us to determine the type of any object in the tuple. It receives two template parameters: the index of the element we’re querying within the tuple, and the tuple class.

Below, we get the type of the first element of our tuple using the shorthand syntax std::tuple_element_t. We then compare it to the int type using std::is_same_v:

1#include <tuple>
2#include <iostream>
3
4template <typename T>
5void HandleTuple(T Tuple){
6  if constexpr (std::is_same_v<
7    std::tuple_element_t<0, T>, int>) {
8    std::cout <<
9      "The first element is an integer";
10  }
11}
12
13int main(){
14  HandleTuple(std::tuple{42, 3.14, true});
15}
16

1The first element is an integer
2

Tuple Concatenation

Tuples are not designed to be resized at run time, but we can concatenate two or more tuples together using the std::tuple_cat function:

1#include <tuple>
2#include <iostream>
3
4int main(){
5  std::tuple Original{42, 3.14, true};
6  std::tuple Additions{9.8f, "Hello"};
7
8  auto Combined{
9    std::tuple_cat(Original, Additions)};
10
11  std::cout << "Combined Tuple Size: "
12    << std::tuple_size_v<decltype(Combined)>;
13
14  std::cout << "\nLast element: "
15    << std::get<4>(Combined);
16}
17

1Combined Tuple Size: 5
2Last element: Hello
3

Tuple Iteration

The standard library’s implementation of a tuple is a very basic implementation, with very limited capabilities. The type does not provide any assistance with iteration.

Additionally, the C++ language itself has limited support for iteration over heterogeneous collections like a tuple. That is planned to be addressed in future versions of the language, with a feature tentatively called expansion statements.

Until then, if we need that capability, we need to do a little more work. We could introduce a third-party library with a more robust implementation.

The following is an example using Boost.Hana in conjunction with a lambda expression. We cover lambda expressions in detail in our later chapter on functions:

1#include <boost/hana.hpp>
2#include <iostream>
3
4int main(){
5  namespace hana = boost::hana;
6  hana::tuple Tuple{42, 3.14, true};
7
8  hana::for_each(Tuple, [](auto Object){
9    std::cout << Object << ", ";
10  });
11}
12

142, 3.14, 1,
2

The following is an example of how to iterate over a tuple using only the standard library. It is also using more advanced functional concepts that we cover in the later chapter:

1#include <tuple>
2#include <iostream>
3
4void Log(auto Object){
5  std::cout << Object << ", ";
6}
7
8int main(){
9  std::tuple MyTuple{42, 3.14f, true};
10
11  std::apply([](auto... Objects){
12    (Log(Objects), ...);
13  }, MyTuple);
14}
15

142, 3.14, 1,
2