Explore the full potential of C++ by mastering the standard library.

Become a C++ Programmer

The C++ standard library is a collection of all the tools and utilities available in C++. It received its latest update in 2017, known as C++17. The update introduces many new features that further optimize our code. This module will help us fully grasp C++ and use it to its full potential.

C++ Standard Library

With [`std::pair`](http://en.cppreference.com/w/cpp/utility/pair), you can build pairs of arbitrary types. The class template `std::pair` needs the header `<utility>`. `std::pair` has a default, copy and move constructor. Pair objects can be swapped: `std::swap(pair1, pair2)`.

Pairs will often be used in the C++ library. For example, the function [std::minmax](https://www.educative.io/courses/cpp-standard-library-including-cpp-14-and-cpp-17/the-min-max-and-minmax-functions) returns its result as a pair, the [associative container](https://www.educative.io/courses/cpp-standard-library-including-cpp-14-and-cpp-17/introduction) `std::map`, `std::unordered_map`, `std::multimap` and `std::unordered_multimap` manage their key/value association in pairs.

To get the elements of a pair `p`, you can either access it directly or via an index. So, with `p.first` or `std::get<0>(p)` you get the first, with `p.second` or `std::get<1>(p)` you get the second element of the pair.

Pairs support the comparison operators `==`, `!=`, `<`, `>`, `<=` and `>=`. If you compare two pairs for identity, at first the members `pair1.first` and `pair2.first` will be compared and then `pair1.second` and `pair2.second`. The same strategy holds for the other comparison operators.

### std::make_pair
C++ has the practical help function [`std::make_pair`](http://en.cppreference.com/w/cpp/utility/pair/make_pair) to generate pairs, without specifying their types. `std::make_pair` automatically deduces their types.

With [`std::pair`](http://en.cppreference.com/w/cpp/utility/pair), you can build pairs of arbitrary types. The class template `std::pair` needs the header `<utility>`. `std::pair` has a default, copy and move constructor. Pair objects can be swapped: `std::swap(pair1, pair2)`.

Pairs will often be used in the C++ library. For example, the function [std::minmax](https://www.educative.io/courses/cpp-standard-library-including-cpp-14-and-cpp-17/the-min-max-and-minmax-functions) returns its result as a pair, the [associative container](https://www.educative.io/courses/cpp-standard-library-including-cpp-14-and-cpp-17/introduction) `std::map`, `std::unordered_map`, `std::multimap` and `std::unordered_multimap` manage their key/value association in pairs.

To get the elements of a pair `p`, you can either access it directly or via an index. So, with `p.first` or `std::get<0>(p)` you get the first, with `p.second` or `std::get<1>(p)` you get the second element of the pair.

Pairs support the comparison operators `==`, `!=`, `<`, `>`, `<=` and `>=`. If you compare two pairs for identity, at first the members `pair1.first` and `pair2.first` will be compared and then `pair1.second` and `pair2.second`. The same strategy holds for the other comparison operators.

# std::make_pair
C++ has the practical help function [`std::make_pair`](http://en.cppreference.com/w/cpp/utility/pair/make_pair) to generate pairs, without specifying their types. `std::make_pair` automatically deduces their types.

The idea of a pair of values often comes handy in programming. C++ allows us to make these pairs.

The Standard Library

Overview

Application of Libraries

Useful Functions

Adaptors for Functions

Pairs and Tuples

Reference Wrappers

Smart Pointers

Type Traits

Time Library

std::any, std::optional, and std::variant

Containers in General

Sequential Containers

Associative Containers in General

Ordered Associative Containers

Unordered Associative Containers

Adaptors for Containers

Iterators

Callable Units

Algorithms

Non-Modifying Algorithms

Modifying Algorithms

More Algorithms

New Algorithms with C++17

Numeric

Strings

String View

Regular Expressions

Input and Output Streams

Conclusion

Pairs