Namespaces
Variants

std::pair<T1,T2>:: pair

From cppreference.net
C++
Utilities library
std::pair
pair ( ) ;
(1) (constexpr depuis C++11)
(conditionnellement explicite depuis C++11)
pair ( const T1 & x, const T2 & y ) ;
(2) (conditionnellement explicite depuis C++11)
(constexpr depuis C++14)
(3)
template < class U1, class U2 >
pair ( U1 && x, U2 && y ) ;
(depuis C++11)
(jusqu'à C++23)
(constexpr depuis C++14)
(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) (conditionnellement explicite depuis C++11)
(constexpr depuis C++14)
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 std:: is_default_constructible_v < T1 > et std:: is_default_constructible_v < T2 > sont tous deux true .

Ce constructeur est explicit si et seulement si soit T1 soit T2 n'est pas implicitement constructible par défaut.

(depuis C++11)
2) Initialise first avec x et second avec y .

Ce constructeur participe à la résolution de surcharge si et seulement si std:: is_copy_constructible_v < T1 > et std:: is_copy_constructible_v < T2 > sont tous deux true .

Ce constructeur est explicit si et seulement si std:: is_convertible_v < const T1 & , T1 > est false ou std:: is_convertible_v < const T2 & , T2 > est false .

(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 first ou second pourrait lier une référence à un objet temporaire .

(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 std:: is_constructible_v < T1, const U1 & > et std:: is_constructible_v < T2, const 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 .

(depuis C++11)

Ce constructeur est défini comme supprimé si l'initialisation de first ou second lierait une référence à un objet temporaire.

(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 first ou second lierait une référence à un objet temporaire.

(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) Soit u1 défini comme std :: get < 0 > ( std:: forward ( u ) ) et u2 comme std :: get < 1 > ( std:: forward ( u ) ) , on note leurs types respectifs U1 et U2 . Initialise first avec u1 et second avec u2 .
Ce constructeur participe à la résolution de surcharge si et seulement si
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) Transmet les éléments de first_args au constructeur de first et transmet 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'en C++11) défini 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 défini par défaut, et est constexpr si le déplacement des deux éléments satisfait aux exigences des fonctions constexpr.

Table des matières

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...> )