Using std::pair

The std::pair template is available within the <utility> header.

After including the header, we can create a std::pair like any other object. The template accepts two parameters - the types of the first and second objects we will store.

Below, we create a std::pair that stores two int objects:

1#include <utility>
2
3int main() {
4  std::pair<int, int> MyPair;
5}

Each type can be different if we wish. Below, we create a std::pair that stores an int and a bool:

1#include <utility>
2
3int main() {
4  std::pair<int, bool> MyPair;
5}

When declaring a std::pair, we can optionally initialize its elements:

1#include <utility>
2
3int main() {
4  std::pair<int, bool> MyPair{42, true};
5}

When doing this, we can omit the template parameters if we wish. The compiler can use class template argument deduction (CTAD) to infer the types, based on the types we used to set the initial values:

1#include <utility>
2
3int main() {
4  std::pair MyPair{42, true};
5}

Using std::make_pair()

The std::make_pair() function provides an alternative way to create std::pair objects:

1#include <utility>
2
3template<typename T1, typename T2>
4void HandlePair(std::pair<T1, T2>) {
5  // ...
6}
7
8int main() {
9  auto MyPair{std::make_pair(42, true)};
10
11  HandlePair(MyPair);
12}

This function determines the type of the pair at runtime and was introduced to reduce the amount of syntax we need to write.

However, features have subsequently been added to the language that does the same thing - most notably class template argument deduction in C++17 - so it's now quite uncommon that we would use std::make_pair(). The previous example can simply be written as:

1#include <utility>
2
3template<typename T1, typename T2>
4void HandlePair(std::pair<T1, T2>) {
5  // ...
6}
7
8int main() {
9  auto MyPair{std::pair(42, true)};
10}

Type Aliasing

std::pair types can potentially get quite verbose. Remember, we can alias a type with a using statement if we want to reduce the amount of noise in our code:

1#include <utility>
2
3namespace Engine {
4struct Character {};
5}
6
7namespace Social {
8struct Guild {};
9}
10
11using GuildMember =
12  std::pair<Engine::Character, Social::Guild>;
13
14int main() {
15  GuildMember MyPair;
16}

The first and second members of a std::pair are available using the first and second member variables, respectively:

1#include <utility>
2#include <iostream>
3
4int main() {
5  std::pair Player{"Anna", 40};
6
7  std::cout << "Name: " << Player.first
8            << "\nLevel: " << Player.second;
9}

1Name: Anna
2Level: 40

Using std::get()

As an alternative to using the first and second member variables, we can alternatively access elements in a pair using the more general std::get function.

• We pass the index we want to access as a template parameter. For std::pair, this will either be 0 or 1
• We pass the pair as a function argument

It looks like this:

1#include <utility>
2#include <iostream>
3
4int main() {
5  std::pair Pair(42, 9.8);
6
7  std::cout
8    << "First: " << std::get<0>(Pair)
9    << "\nSecond: " << std::get<1>(Pair);
10}

1First: 42
2Second: 9.8

When the types within our pair are of different types, we can instead get an element by type, rather than index:

1#include <iostream>
2#include <utility>
3
4int main() {
5  std::pair Pair(42, 9.8);
6
7  std::cout
8    << "Double: " << std::get<double>(Pair)
9    << "\nInt: " << std::get<int>(Pair);
10}

1Double: 9.8
2Int: 42

The primary reason std::get exists is to support templates. For example, if our template needs to access the first object in our collection, and we do that using the first member variable, that limits our template to just being compatible with pairs.

If we use the std::get approach instead, our template could work with any type that implements std::get, not just pairs.

For example, std::array also implements std::get, so in the following example, we write a template that is compatible with both std::pair and std::array types:

1#include <utility>
2#include <array>
3#include <iostream>
4
5template <typename T>
6void LogFirst(T Container) {
7  std::cout << "\nFirst: "
8    << std::get<0>(Container);
9}
10
11int main() {
12  LogFirst(std::pair{1, 9.8});
13  LogFirst(std::array{1, 2, 3, 4, 5});
14}

1First: 1
2First: 1

Structured Binding

The std::pair class implements the structured binding operator, which we'll commonly use to access (and optionally rename) both the first and second variables in a single expression:

1#include <utility>
2#include <iostream>
3
4int main() {
5  std::pair Player{"Anna", 40};
6
7  auto [Name, Level]{Player};
8
9  std::cout << "Name: " << Name
10            << "\nLevel: " << Level;
11}

1Name: Anna
2Level: 40

We can access and update the first and second members in the usual ways:

1#include <utility>
2#include <iostream>
3
4int main() {
5  std::pair Player{"Anna", 40};
6
7  Player.first = "Roderick";
8  ++Player.second;
9
10  std::cout << "Name: " << Player.first
11            << "\nLevel: " << Player.second;
12}

1Name: Roderick
2Level: 41

We can also replace the std::pair entirely using the = operator:

1#include <utility>
2#include <iostream>
3
4int main() {
5  std::pair Player{"Anna", 40};
6  Player = std::pair("Roderick", 41);
7
8  std::cout << "Name: " << Player.first
9            << "\nLevel: " << Player.second;
10}

1Name: Roderick
2Level: 41

Like any container, the objects within a std::pair can be references or pointers:

1#include <utility>
2#include <iostream>
3
4int main() {
5  int x{1};
6  int y{2};
7
8  std::pair<int&, int*> Pair{x, &y};
9
10  std::cout << "First: " << Pair.first;
11  std::cout << "\nSecond: " << *(Pair.second);
12}

1First: 1
2Second: 2

They can also use const as required. Below, our pair type stores a const reference, and a const pointer-to-const:

1#include <utility>
2
3int main() {
4  int x{1};
5  int y{2};
6
7  std::pair<const int&, const int* const> Pair{
8    x, &y
9  };
10
11  // Cannot modify const reference
12  Pair.first++;
13
14  // Cannot modify pointer-to-const
15  *(Pair.second)++;
16
17  // Cannot modify const pointer
18  int z{3};
19  Pair.second = 3;
20}

The std::pair itself can also be passed around as a reference or a pointer, with or without const:

1#include <utility>
2
3void HandlePair(const std::pair<int, int> P) {
4  P = std::pair(3, 4);
5}
6
7int main() {
8  std::pair<int, int> Pair{1, 2};
9  HandlePair(Pair);
10}

1error: binary '=': no operator found which takes a left-hand operand of type 'const std::pair<int,int>'

When creating templates that receive std::pair objects, there are some useful class members we can use:

• first_type returns the type of the first object
• second_type returns the type of the second object

1#include <utility>
2#include <iostream>
3
4template <typename T>
5void HandlePair(T Pair) {
6  std::cout << "First Type: "
7    << typeid(T::first_type).name();
8  std::cout << "\nSecond Type: "
9    << typeid(T::second_type).name();
10}
11
12int main() {
13  std::pair<int, bool> Pair;
14  HandlePair(Pair);
15}

1First Type: int
2Second Type: bool

Below, we use the first_type member with the std::same_as concept to implement different behaviors based on the first type in our template argument. In this case, we need to prepend the typename to specify that we expect T::first_type is going to be a type:

1#include <utility>
2#include <iostream>
3
4template <typename T>
5void HandlePair(T Pair) {
6  constexpr bool FirstIsInt{
7    std::same_as<typename T::first_type, int>};
8
9  if constexpr (FirstIsInt) {
10    std::cout << "First type is int";
11  }
12}
13
14int main() {
15  std::pair<int, int> Pair;
16  HandlePair(Pair);
17}

1First type is int

Below, we use this member to create a concept that is satisfied if the std::pair has a first type that is a Character, or a type derived from Character:

1#include <utility>
2#include <iostream>
3
4class Character {};
5
6template <typename T>
7concept FirstIsCharacter = std::derived_from<
8  typename T::first_type, Character>;
9
10void HandlePair(FirstIsCharacter auto Pair) {
11  // ...
12}
13
14int main() {
15  std::pair<int, int> Pair;
16  HandlePair(Pair);
17}

The concept is not satisfied in this example, as int does not derive from Character:

1error: main.cpp(16,3):
2the associated constraints are not satisfied
3the concept 'FirstIsCharacter<std::pair<int,int>>' evaluated to false
4the concept 'std::derived_from<int,Character>' evaluated to false

A tuple is a container that can store a collection of objects that potentially have different types. We'll introduce the C++ standard library's implementation of this - std::tuple - in the next chapter.

But, a std::pair is also a tuple - it is simply a tuple with its size constrained to two objects. As such, instead of writing our templates using pair-specific APIs such as first_type and second_type, we might want to use a tuple interface instead

This would allow our templates to still work with std::pair, but potentially larger tuples too.

Using std::tuple_element<>

The std::tuple_element template accepts two template parameters - the index of the type we want to retrieve, and the type of the tuple (or pair) we're querying.

The type at that index is then available as the ::type static member. Alternatively, we can use std::tuple_element_t to access the type directly.

The following three statements are equivalent, with the first_type and second_type approaches being specific to std::pair:

1template <typename T>
2void HandlePair(T Tuple) {
3  // First type
4  T::first_type;
5  std::tuple_element<0, T>::type;
6  std::tuple_element_t<0, T>;
7
8  // Second type
9  T::second_type;
10  std::tuple_element<1, T>::type;
11  std::tuple_element_t<1, T>;
12}

Below, we use this to log out the types:

1#include <utility>
2#include <iostream>
3
4template <typename T>
5void HandlePair(T Tuple) {
6  using std::tuple_element_t;
7  std::cout << "First Type: "
8    << typeid(tuple_element_t<0, T>).name();
9  std::cout << "\nSecond Type: "
10    << typeid(tuple_element_t<1, T>).name();
11}
12
13int main() {
14  std::pair<int, bool> Pair;
15  HandlePair(Pair);
16}

1First Type: int
2Second Type: bool

In this example, we use it to create a concept:

1#include <utility>
2#include <iostream>
3
4class Character {};
5
6template <typename T>
7concept FirstIsCharacter = std::derived_from<
8  std::tuple_element_t<0, T>, Character>;
9
10void HandlePair(FirstIsCharacter auto Pair) {
11  // ...
12}
13
14int main() {
15  std::pair<int, int> Pair;
16  HandlePair(Pair);
17}

1error: main.cpp(16,3):
2the associated constraints are not satisfied
3the concept 'FirstIsCharacter<std::pair<int,int>>' evaluated to false
4the concept 'std::derived_from<int,Character>' evaluated to false

Using std::tuple_size<>

The std::tuple_size trait receives our type as a template parameter and returns how many objects the type contains. This is available through the ::value member, or directly by using std::tuple_size_v.

For a pair specifically, this will always be 2:

1#include <utility>
2#include <iostream>
3
4template <typename T>
5void HandlePair(T Tuple) {
6  std::cout << "Size: "
7    << std::tuple_size<T>::value;
8
9  // Alternatively:
10  std::cout << "\nSize: "
11    << std::tuple_size_v<T>;
12}
13
14int main() {
15  std::pair<int, bool> Pair;
16  HandlePair(Pair);
17}

1Size: 2
2Size: 2

Below, we use this to implement a concept that is only satisfied by tuples of size 2:

1#include <utility>
2#include <iostream>
3
4template <typename T>
5concept TupleSize2 = std::tuple_size_v<T> == 2;
6
7void HandlePair(TupleSize2 auto P) { 
8  std::cout << "First: " << std::get<0>(P);
9  std::cout << "\nSecond: " << std::get<1>(P);
10  // ...
11}
12
13int main() {
14  HandlePair(std::pair(42, 9.8));
15}

1First: 42
2Second: 9.8

We cover more complex tuple topics, such as iteration, in our later lesson on std::tuple.

In this lesson, we explored the fundamental std::pair container, learning how to create, access, and manipulate it in a variety of ways. We also delved into how std::pair interfaces with other C++ features like structured bindings, type traits, and the tuple interface, broadening its utility.

Key Takeaways

• std::pair is a simple, heterogeneous container for storing two related objects.
• Pairs can be created and initialized directly or through the std::make_pair() function, with or without specifying types explicitly.
• Member variables first and second provide direct access to the pair's elements.
• std::get() offers an alternative way to access pair elements by index or type.
• Structured binding allows for the convenient unpacking of a pair's elements.
• Pairs can contain references and pointers, and use const qualifiers for added flexibility.
• Type aliasing can be used to simplify verbose std::pair types in code.
• std::pair supports tuple interfaces such as std::tuple_element and std::tuple_size for more versatile template programming.
• Concepts and type traits can be applied to std::pair for more robust and type-safe template functions.