std::pair<T1,T2>::pair
Depuis fr.cppreference.net
pair();
|
(1) | (constexpr depuis C++11) (conditionnellement explicite depuis C++11) |
pair( const T1& x, const T2& y );
|
(2) | (constexpr depuis C++14) (conditionnellement explicite depuis C++11) |
template< class U1, class U2 >
pair( U1&& x, U2&& y );
|
(3) | (depuis C++11) (constexpr depuis C++14) (jusqu'à C++23) (conditionnellement explicite) |
template< class U1 = T1, class U2 = T2 >
constexpr pair( U1&& x, U2&& y );
|
(depuis C++23) (conditionnellement explicite) |
|
template< class U1, class U2 >
constexpr pair( pair<U1, U2>& p );
|
(4) | (depuis C++23) (conditionnellement explicite) |
template< class U1, class U2 >
pair( const pair<U1, U2>& p );
|
(5) | (constexpr depuis C++14) (conditionnellement explicite depuis C++11) |
template< class U1, class U2 >
pair( pair<U1, U2>&& p );
|
(6) | (constexpr depuis C++14) (conditionnellement explicite depuis C++11) |
template< class U1, class U2 >
constexpr pair( const pair<U1, U2>&& p );
|
(7) | (depuis C++23) (conditionnellement explicite) |
template< pair-like P >
constexpr pair ( P&& u );
|
(8) | (depuis C++23) (conditionnellement explicite) |
template< class... Args1, class... Args2 >
pair( std::piecewise_construct_t,
std::tuple<Args1...> first_args,
std::tuple<Args2...> second_args );
|
(9) | (depuis C++11) (constexpr depuis C++20) |
pair( const pair& p ) = default;
|
(10) | |
pair( pair&& p ) = default;
|
(11) | (depuis C++11) |
Construit une nouvelle paire.
1) Constructeur par défaut. Initialise par valeur les deux éléments de la paire,
first et second.
|
Ce constructeur participe à la résolution de surcharge si et seulement si Ce constructeur est |
(depuis C++11) |
2) Initialise
first avec x et second avec y.
|
Ce constructeur participe à la résolution de surcharge si et seulement si Ce constructeur est |
(depuis C++11) |
3) Initialise
first avec std::forward<U1>(x) et second avec std::forward<U2>(y). Ce constructeur participe à la résolution de surcharge si et seulement si
std::is_constructible_v<T1, U1> et std::is_constructible_v<T2, U2> sont tous deux true. Ce constructeur est
explicit si et seulement si std::is_convertible_v<U1, T1> est false ou std::is_convertible_v<U2, T2> est false.
|
Ce constructeur est défini comme supprimé si l'initialisation de |
(depuis C++23) |
4) Initialise
first avec p.first et second avec p.second. Ce constructeur participe à la résolution de surcharge si et seulement si
std::is_constructible_v<T1, U1&> et std::is_constructible_v<T2, U2&> sont tous deux true. Ce constructeur est
explicit si et seulement si std::is_convertible_v<U1&, T1> est false ou std::is_convertible_v<U2&, T2> est false. Ce constructeur est défini comme supprimé si l'initialisation de
first ou second lierait une référence à un objet temporaire.5) Initialise
first avec p.first et second avec p.second.
|
Ce constructeur participe à la résolution de surcharge si et seulement si Ce constructeur est |
(depuis C++11) |
|
Ce constructeur est défini comme supprimé si l'initialisation de |
(depuis C++23) |
6) Initialise
first avec std::forward<U1>(p.first) et second avec std::forward<U2>(p.second). Ce constructeur participe à la résolution de surcharge si et seulement si
std::is_constructible_v<T1, U1> et std::is_constructible_v<T2, U2> sont tous deux true. Ce constructeur est
explicit si et seulement si std::is_convertible_v<U1, T1> est false ou std::is_convertible_v<U2, T2> est false.
|
Ce constructeur est défini comme supprimé si l'initialisation de |
(depuis C++23) |
7) Initialise
first avec std::forward<const U1>(p.first) et second avec std::forward<const U2>(p.second). Ce constructeur participe à la résolution de surcharge si et seulement si
std::is_constructible_v<T1, U1> et std::is_constructible_v<T2, U2> sont tous deux true. Ce constructeur est
explicit si et seulement si std::is_convertible_v<const U1, T1> est false ou std::is_convertible_v<const U2, T2> est false. Ce constructeur est défini comme supprimé si l'initialisation de
first ou second lierait une référence à un objet temporaire.8) Étant donné
u1 comme std::get<0>(std::forward(u)) et u2 comme std::get<1>(std::forward(u)), leurs types sont désignés respectivement par U1 et U2. Initialise first avec u1 et second avec u2. Ce constructeur participe à la résolution de surcharge si et seulement si
std::remove_cvref(P)n'est pas une spécialisation de std::ranges::subrange,std::is_constructible_v<T1, U1>esttrue, etstd::is_constructible_v<T2, U2esttrue.
Ce constructeur est
explicit si et seulement si std::is_convertible_v<U1, T1> est false ou std::is_convertible_v<U2, T2> est false. Ce constructeur est défini comme supprimé si l'initialisation de
first ou second lierait une référence à un objet temporaire.9) Transfère les éléments de
first_args au constructeur de first et transfère les éléments de second_args au constructeur de second. C'est le seul constructeur non par défaut qui peut être utilisé pour créer une paire de types non copiables et non déplaçables. Le programme est mal formé si first ou second est une référence et lié à un objet temporaire.10) Le constructeur de copie est implicitement déclaré(jusqu'à C++11)par défaut, et est
constexpr si la copie des deux éléments satisfait aux exigences des fonctions constexpr(depuis C++11).11) Le constructeur de déplacement est par défaut, et est
constexpr si le déplacement des deux éléments satisfait aux exigences des fonctions constexpr.Paramètres
| x | - | valeur pour initialiser le premier élément de cette paire |
| y | - | valeur pour initialiser le deuxième élément de cette paire |
| p | - | paire de valeurs utilisée pour initialiser les deux éléments de cette paire |
| u | - | pair-like objet de valeurs utilisé pour initialiser les deux éléments de cette paire |
| first_args | - | tuple d'arguments de constructeur pour initialiser le premier élément de cette paire |
| second_args | - | tuple d'arguments de constructeur pour initialiser le deuxième élément de cette paire |
Exceptions
Ne lance pas d'exceptions sauf si l'une des opérations spécifiées (par exemple, le constructeur d'un élément) lance.
Exemple
Exécuter ce code
#include <complex> #include <iostream> #include <string> #include <tuple> #include <utility> int main() { auto print = [](auto rem, auto const& pair) { std::cout << rem << "(" << pair.first << ", " << pair.second << ")\n"; }; std::pair<int, float> p1; print("(1) Value-initialized: ", p1); std::pair<int, double> p2{42, 3.1415}; print("(2) Initialized with two values: ", p2); std::pair<char, int> p4{p2}; print("(4) Implicitly converted: ", p4); std::pair<std::complex<double>, std::string> p6 {std::piecewise_construct, std::forward_as_tuple(0.123, 7.7), std::forward_as_tuple(10, 'a')}; print("(8) Piecewise constructed: ", p6); }
Sortie possible :
(1) Value-initialized: (0, 0) (2) Initialized with two values: (42, 3.1415) (4) Implicitly converted: (*, 3) (8) Piecewise constructed: ((0.123,7.7), aaaaaaaaaa)
Rapports de défauts
Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.
| DR | Appliqué à | Comportement publié | Comportement corrigé |
|---|---|---|---|
| LWG 265 | C++98 |
le constructeur par défaut initialisait par copie
first
et
second
avec
T1
(
)
et
T2
(
)
respectivement
(requérait donc que
T1
et
T2
soient
CopyConstructible
)
|
first
et
second
sont initialisés par valeur |
| LWG 2510 | C++11 | le constructeur par défaut était implicite | rendu conditionnellement-explicite |
| N4387 | C++11 | certains constructeurs étaient uniquement implicites, empêchant certaines utilisations | constructeurs rendus conditionnellement-explicites |
Voir aussi
crée un objet
pair
du type déterminé par les types d'arguments
(modèle de fonction) |
|
construit un nouveau
tuple
(fonction membre publique de
std::tuple<Types...>
)
|