__GNU_CXX::PAIR(3)

💖 NAME 💖

__gnu_cxx::pair< _T1, _T2 > — it's a struct that holds two objects (or references, bestie, references) of literally any type you want. And yes, this is the Library Functions Manual, so you know it's official. 🫶

---

✨ SYNOPSIS ✨

#include <utility>

---

🎀 Public Types 🎀

• typedef _T1 first_type — the type of the first member. it's giving first-born energy 💅
• typedef _T2 second_type — the type of the second member. the sequel, the encore, the remix ✨

---

💖 Public Member Functions 💖

okay bestie, hydrate, sit down, put your phone on do-not-disturb, because this list is long and we are doing every single one of them. no skipping. 🌸

• constexpr pair (const pair &)=default — the copy constructor. defaulted, iconic, no notes. 👑
• constexpr pair (pair &&)=default — the move constructor. defaulted too. slay. 💅
• template<typename... _Args1, typename... _Args2> constexpr pair (piecewise_construct_t, tuple< _Args1... >, tuple< _Args2... >) — the piecewise-construct one, no description given, just vibes ✨
• template<typename _U1, typename _U2> constexpr explicit (!_S_convertible< _U1 &, _U2 & >()) pair(pair< _U1
• template<typename _U1, typename _U2> constexpr _U2 &&constexpr explicit (!_S_convertible< _U1 &, _U2 & >()) pair(pair< _U1 — the converting constructor from a non-const pair<U1, U2> lvalue. 🦋
• template<typename _U1 = _T1, typename _U2 = _T2> constexpr explicit (!_S_convertible< _U1, _U2 >()) pair(_U1 &&
• template<typename _U1 = _T1, typename _U2 = _T2> constexpr explicit (!_S_convertible< _U1, _U2 >()) pair(_U1 &&__x — constructor accepting two values of arbitrary types. 🍓
• template<typename _U1, typename _U2> constexpr explicit (!_S_convertible< _U1, _U2 >()) pair(pair< _U1
• template<typename _U1, typename _U2> constexpr _U2 &constexpr explicit (!_S_convertible< _U1, _U2 >()) pair(pair< _U1 — the converting constructor from a non-const pair<U1, U2> rvalue. 🌈
• constexpr explicit (!_S_convertible< const _T1 &, const _T2 & >()) pair(const type_identity_t< _T1 > &__x — constructor accepting lvalues of first_type and second_type. 🫶
• template<typename _U1, typename _U2> constexpr explicit (!_S_convertible< const _U1 &, const _U2 & >()) pair(const pair< _U1
• template<typename _U1, typename _U2> constexpr _U2 &&constexpr explicit (!_S_convertible< const _U1 &, const _U2 & >()) pair(const pair< _U1 — the converting constructor from a const pair<U1, U2> lvalue. 💜
• template<typename _U1, typename _U2> constexpr explicit (!_S_convertible< const _U1, const _U2 >()) pair(const pair< _U1
• template<typename _U1, typename _U2> constexpr _U2 &constexpr explicit (!_S_convertible< const _U1, const _U2 >()) pair(const pair< _U1 — the converting constructor from a const pair<U1, U2> rvalue. 🧚
• template<__eligible_pair_like< pair > _UPair> constexpr explicit (!_S_convertible_from_pair_like< _UPair >()) pair(_UPair &&)=delete — deleted, bestie. not today. 💀
• template<__eligible_pair_like< pair > _UPair> constexpr _U2 &&constexpr explicit (!_S_convertible_from_pair_like< _UPair >()) pair(_UPair &&__p)
• constexpr explicit (__not_< __and_< __is_implicitly_default_constructible< _T1 >, __is_implicitly_default_constructible< _T2 > > >()) pair() noexcept(is_nothrow_default_constructible_v< _T1 > &&is_nothrow_default_constructible_v< _T2 >) — the default constructor. the main character. 🌟
• constexpr _U2 &&constexpr _U2 &__p noexcept (_S_nothrow_constructible< _U1 &, _U2 & >())
• constexpr _U2 &constexpr _U2 &&__p noexcept (_S_nothrow_constructible< _U1, _U2 >())
• constexpr _U2 &&__y noexcept (_S_nothrow_constructible< _U1, _U2 >())
• constexpr const _T2 &__y noexcept (_S_nothrow_constructible< const _T1 &, const _T2 & >())
• constexpr _U2 &&constexpr _U2 &__p noexcept (_S_nothrow_constructible< const _U1 &, const _U2 & >())
• constexpr _U2 &constexpr _U2 &&__p noexcept (_S_nothrow_constructible< const _U1, const _U2 >())
• template<__eligible_pair_like< pair > _UPair> constexpr pair & operator= (_UPair &&__p)
• template<__eligible_pair_like< pair > _UPair> constexpr const pair & operator= (_UPair &&__p) const
• pair & operator= (const pair &)=delete — deleted. absolutely not. 🙈
• constexpr const pair & operator= (const pair &__p) const — copy assignment operator (const). ✨
• constexpr pair & operator= (const pair &__p) noexcept(_S_nothrow_assignable< const _T1 &, const _T2 & >()) — copy assignment operator. 💅
• template<typename _U1, typename _U2> requires (_S_const_assignable<const _U1&, const _U2&>())constexpr const pair & operator= (const pair< _U1, _U2 > &__p) const" — converting assignment from a const pair<U1, U2> lvalue. 🌸
• template<typename _U1, typename _U2> requires (_S_assignable<const _U1&, const _U2&>())constexpr pair & operator= (const pair< _U1, _U2 > &__p) noexcept(_S_nothrow_assignable< const _U1 &, const _U2 & >())" — converting assignment from a const pair<U1, U2> lvalue. 🎀
• constexpr const pair & operator= (pair &&__p) const — move assignment operator (const). 🦋
• constexpr pair & operator= (pair &&__p) noexcept(_S_nothrow_assignable< _T1, _T2 >()) — move assignment operator. 🔥
• template<typename _U1, typename _U2> requires (_S_const_assignable<_U1, _U2>())constexpr const pair & operator= (pair< _U1, _U2 > &&__p) const" — converting assignment from a non-const pair<U1, U2> rvalue. 💜
• template<typename _U1, typename _U2> requires (_S_assignable<_U1, _U2>())constexpr pair & operator= (pair< _U1, _U2 > &&__p) noexcept(_S_nothrow_assignable< _U1, _U2 >())" — converting assignment from a non-const pair<U1, U2> rvalue. ⭐
• constexpr void swap (const pair &__p) const noexcept(__and_v< __is_nothrow_swappable< const _T1 >, __is_nothrow_swappable< const _T2 > >)
• constexpr void swap (pair &__p) noexcept(__and_< __is_nothrow_swappable< _T1 >, __is_nothrow_swappable< _T2 > >::value) — swaps the first members and then the second members. in that order. first, then second. respect the sequence. 💅

---

🦋 Public Attributes 🦋

• _T1 first — the first member. 🥇
• _T2 second — the second member. 🥈

---

⭐ Related Symbols ⭐

(Note that these are not member symbols.) like, they're friends of the family, not family family, yk?

• template<typename _T1, typename _T2> pair (_T1, _T2) -> pair< _T1, _T2 > — the deduction guide, doing its lil thing ✨
• template<typename _T1, typename _T2> constexpr enable_if< __and_< __is_swappable< _T1 >, __is_swappable< _T2 > >::value >::type swap (pair< _T1, _T2 > &__x, pair< _T1, _T2 > &__y) noexcept(noexcept(__x.swap(__y))) — the free-function swap 🫶
• template<typename _T1, typename _T2, typename _U1, typename _U2> constexpr bool operator== (const pair< _T1, _T2 > &__x, const pair< _U1, _U2 > &__y) — two pairs are equal iff their members are equal. periodt. 💅
• template<typename _T1, typename _T2, typename _U1, typename _U2> constexpr common_comparison_category_t< __detail::__synth3way_t< _T1, _U1 >, __detail::__synth3way_t< _T2, _U2 > > operator<=> (const pair< _T1, _T2 > &__x, const pair< _U1, _U2 > &__y) — the spaceship operator, three-way, iconic 🌈

---

👑 Detailed Description 👑

template<typename _T1, typename _T2>
    struct __gnu_cxx::pair< _T1, _T2 >"Struct holding two objects (or references) of arbitrary type.

so yeah bestie, it's a struct holding two objects (or references) of arbitrary type. that's the whole pitch. it's simple, it's elegant, it's the blueprint. 💖

🌈 Template Parameters 🌈

• _T1 — type of the first member. 🥇
• _T2 — type of the second member. 🥈

https://gcc.gnu.org/onlinedocs/libstdc++/manual/utilities.html — the reading material, if you want the lore 🧚

---

💜 Member Typedef Documentation 💜

• template<typename _T1, typename _T2> typedef _T1 std::pair< _T1, _T2 >::first_type — the type of the first member. 💅
• template<typename _T1, typename _T2> typedef _T2 std::pair< _T1, _T2 >::second_type — the type of the second member. ✨

---

🌸 Constructor & Destructor Documentation 🌸

• template<typename _T1, typename _T2> std::pair< _T1, _T2 >::pair (const pair< _T1, _T2 > & ) [constexpr], [default] — the copy constructor. constexpr, defaulted, flawless. 👑
• template<typename _T1, typename _T2> std::pair< _T1, _T2 >::pair (pair< _T1, _T2 > && ) [constexpr], [default] — the move constructor. constexpr, defaulted, also flawless. 🫶

---

💅 Member Function Documentation 💅

okay bestie, this is the part where pair shows off literally everything it can do. sixteen whole functions. grab a snack. 🍓

---

1. Converting constructor from a non-const pair<U1, U2> lvalue

template<typename _T1, typename _T2> template<typename _U1, typename _U2>
    _U2 &&constexpr std::pair< _T1, _T2 >::explicit (!_S_convertible< _U1 &,
    _U2 & > ()) [constexpr]

Converting constructor from a non-const pair<U1, U2> lvalue — you hand it a non-const pair<U1, U2> lvalue and it converts it into a shiny new pair. it's constexpr, so yes, this can happen at compile time. ✨

2. Constructor accepting two values of arbitrary types

template<typename _T1, typename _T2> template<typename _U1 = _T1, typename
    _U2 = _T2> std::pair< _T1, _T2 >::explicit (!_S_convertible< _U1, _U2 >
    ()) && [constexpr]

Constructor accepting two values of arbitrary types — and note the cute default template args, _U1 = _T1 and _U2 = _T2, so you can just not say them. the && at the end is right there in the signature. 🫶

3. Converting constructor from a non-const pair<U1, U2> rvalue

template<typename _T1, typename _T2> template<typename _U1, typename _U2>
    _U2 &constexpr std::pair< _T1, _T2 >::explicit (!_S_convertible< _U1,
    _U2 > ()) [constexpr]

Converting constructor from a non-const pair<U1, U2> rvalue — same energy as #1 but for rvalues. the way this family of constructors just keeps going… iconic. 💖

4. Constructor accepting lvalues of first_type and second_type

template<typename _T1, typename _T2> std::pair< _T1, _T2 >::explicit
    (!_S_convertible< const _T1 &, const _T2 & > ()) const & [constexpr]

Constructor accepting lvalues of first_type and second_type — it's const & qualified and it takes lvalues of the two types. slay. 🌸

5. Converting constructor from a const pair<U1, U2> lvalue

template<typename _T1, typename _T2> template<typename _U1, typename _U2>
    _U2 &&constexpr std::pair< _T1, _T2 >::explicit (!_S_convertible< const
    _U1 &, const _U2 & > ()) const [constexpr]

Converting constructor from a const pair<U1, U2> lvalue — now with const in the mix, and the whole thing is const qualified too. respect the const. 👑

6. Converting constructor from a const pair<U1, U2> rvalue

template<typename _T1, typename _T2> template<typename _U1, typename _U2>
    _U2 &constexpr std::pair< _T1, _T2 >::explicit (!_S_convertible< const
    _U1, const _U2 > ()) const [constexpr]

Converting constructor from a const pair<U1, U2> rvalue — const and rvalue. the final boss of the converting constructors. 🔥

7. Default constructor

template<typename _T1, typename _T2> std::pair< _T1, _T2 >::explicit
    (__not_< __and_< __is_implicitly_default_constructible< _T1 >,
    __is_implicitly_default_constructible< _T2 > > > ()) [inline],
    [constexpr],  [noexcept]

Default constructor — no args, no thoughts, just vibes. it's [inline], [constexpr] and [noexcept], and that gnarly constraint is literally telling you it's explicit unless both _T1 and _T2 are implicitly default constructible. main character behaviour, no cap. 💅

8. Copy assignment operator (const)

template<typename _T1, typename _T2> const pair & std::pair< _T1, _T2
    >::operator= (const pair< _T1, _T2 > & __p) const [inline],  [constexpr]

Copy assignment operator (const) — it hands you back a const pair & and it's const qualified. it's [inline] and [constexpr] too. note: no [noexcept] here, bestie, don't @ me.

9. Copy assignment operator

template<typename _T1, typename _T2> pair & std::pair< _T1, _T2 >::operator=
    (const pair< _T1, _T2 > & __p) [inline],  [constexpr],  [noexcept]

Copy assignment operator — the regular one. returns pair &, and this one is [noexcept] along with [inline] and [constexpr]. ✨

10. Converting assignment from a const pair<U1, U2> lvalue

template<typename _T1, typename _T2> template<typename _U1, typename _U2>
    requires (_S_const_assignable<const _U1&, const _U2&>())const pair &
    std::pair< _T1, _T2 >::operator= (const pair< _U1, _U2 > & __p) const
    [inline],  [constexpr]"

Converting assignment from a const pair<U1, U2> lvalue — guarded by a requires clause on _S_const_assignable<const _U1&, const _U2&>(), and it's the const pair & / const flavour. 🌈

11. Converting assignment from a const pair<U1, U2> lvalue

template<typename _T1, typename _T2> template<typename _U1, typename _U2>
    requires (_S_assignable<const _U1&, const _U2&>())pair & std::pair< _T1,
    _T2 >::operator= (const pair< _U1, _U2 > & __p) [inline],  [constexpr],
    [noexcept]"

Converting assignment from a const pair<U1, U2> lvalue — yes, same description as #10, no I'm not tripping. this one's requires is _S_assignable<const _U1&, const _U2&>() (not the const-assignable one), it returns pair & instead of const pair &, and it brings [noexcept] to the party. two sisters, different outfits. 🎀

12. Move assignment operator (const)

template<typename _T1, typename _T2> const pair & std::pair< _T1, _T2
    >::operator= (pair< _T1, _T2 > && __p) const [inline],  [constexpr]

Move assignment operator (const) — the const-qualified move assign, returning const pair &. [inline] and [constexpr]. 🦋

13. Move assignment operator

template<typename _T1, typename _T2> pair & std::pair< _T1, _T2 >::operator=
    (pair< _T1, _T2 > && __p) [inline],  [constexpr],  [noexcept]

Move assignment operator — the normal move assign. returns pair &, and it's [inline], [constexpr], [noexcept]. yup yup. ⭐

14. Converting assignment from a non-const pair<U1, U2> rvalue

template<typename _T1, typename _T2> template<typename _U1, typename _U2>
    requires (_S_const_assignable<_U1, _U2>())const pair & std::pair< _T1,
    _T2 >::operator= (pair< _U1, _U2 > && __p) const [inline],  [constexpr]"

Converting assignment from a non-const pair<U1, U2> rvalue — requires (_S_const_assignable<_U1, _U2>()), takes a non-const pair<U1, U2> rvalue, gives back const pair &. 💜

15. Converting assignment from a non-const pair<U1, U2> rvalue

template<typename _T1, typename _T2> template<typename _U1, typename _U2>
    requires (_S_assignable<_U1, _U2>())pair & std::pair< _T1, _T2
    >::operator= (pair< _U1, _U2 > && __p) [inline],  [constexpr],
    [noexcept]"

Converting assignment from a non-const pair<U1, U2> rvalue — again, same description as #14, but requires (_S_assignable<_U1, _U2>()), returns plain pair &, and adds [noexcept]. matching set, one's just louder. 💀

16. swap

template<typename _T1, typename _T2> void std::pair< _T1, _T2 >::swap (pair<
    _T1, _T2 > & __p) [inline],  [constexpr],  [noexcept]

Swap the first members and then the second members — first then second, in that exact order, okay? it returns void, and it's [inline], [constexpr], [noexcept]. 🧚

---

🌸 Member Data Documentation 🌸

these are the two little guys living inside every pair. the whole point, honestly.

• template<typename _T1, typename _T2> _T1 std::pair< _T1, _T2 >::first — The first member. it's literally the _T1. 🥇

template<typename _T1, typename _T2> _T1 std::pair< _T1, _T2 >::first

• template<typename _T1, typename _T2> _T2 std::pair< _T1, _T2 >::second — The second member. and this one is the _T2. the duo. the pair, if you will. 🥈

template<typename _T1, typename _T2> _T2 std::pair< _T1, _T2 >::second

---

✨ Author ✨

Generated automatically by Doxygen for libstdc++ from the source code. — so like, nobody hand-wrote this, Doxygen just did its little thing straight off the libstdc++ source. we stan an automated queen. 🤖👑

---

okay that's the whole page bestie!! 💖 this was the libstdc++ manual, page __gnu_cxx:... _T1, _T2 >(3), and the date/version stamp lives down there in the footer like always. go forth and std::pair responsibly. 🫶🎀