Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::pair
pair ( ) ;
(1) (constexpr seit C++11)
(bedingt explicit seit C++11)
pair ( const T1 & x, const T2 & y ) ;
(2) (bedingt explicit seit C++11)
(constexpr seit C++14)
(3)
template < class U1, class U2 >
pair ( U1 && x, U2 && y ) ;
(seit C++11)
(bis C++23)
(constexpr seit C++14)
(bedingt explizit)
template < class U1 = T1, class U2 = T2 >
constexpr pair ( U1 && x, U2 && y ) ;
(seit C++23)
(bedingt explizit)
template < class U1, class U2 >
constexpr pair ( pair < U1, U2 > & p ) ;
(4) (seit C++23)
(bedingt explizit)
template < class U1, class U2 >
pair ( const pair < U1, U2 > & p ) ;
(5) (bedingt explizit seit C++11)
(constexpr seit C++14)
template < class U1, class U2 >
pair ( pair < U1, U2 > && p ) ;
(6) (constexpr seit C++14)
(bedingt explizit seit C++11)
template < class U1, class U2 >
constexpr pair ( const pair < U1, U2 > && p ) ;
(7) (seit C++23)
(bedingt explizit)
template < pair - like P >
constexpr pair ( P && u ) ;
(8) (seit C++23)
(bedingt explizit)
template < class ... Args1 , class ... Args2 >

pair ( std:: piecewise_construct_t ,
std:: tuple < Args1... > first_args,

std:: tuple < Args2... > second_args ) ;
(9) (seit C++11)
(constexpr seit C++20)
pair ( const pair & p ) = default ;
(10)
pair ( pair && p ) = default ;
(11) (seit C++11)

Konstruiert ein neues Paar.

1) Standardkonstruktor. Wertinitialisiert beide Elemente des Paares, first und second .

Dieser Konstruktor nimmt an der Überladungsauflösung teil, genau dann wenn std:: is_default_constructible_v < T1 > und std:: is_default_constructible_v < T2 > beide true sind.

Dieser Konstruktor ist explicit genau dann wenn entweder T1 oder T2 nicht implizit standardkonstruierbar ist.

(since C++11)
2) Initialisiert first mit x und second mit y .

Dieser Konstruktor nimmt an der Überladungsauflösung teil, genau dann wenn std:: is_copy_constructible_v < T1 > und std:: is_copy_constructible_v < T2 > beide true sind.

Dieser Konstruktor ist explicit genau dann wenn std:: is_convertible_v < const T1 & , T1 > false ist oder std:: is_convertible_v < const T2 & , T2 > false ist.

(seit C++11)
3) Initialisiert first mit std:: forward < U1 > ( x ) und second mit std:: forward < U2 > ( y ) .
Dieser Konstruktor nimmt an der Überladungsauflösung teil, genau dann wenn std:: is_constructible_v < T1, U1 > und std:: is_constructible_v < T2, U2 > beide true sind.
Dieser Konstruktor ist explicit genau dann, wenn std:: is_convertible_v < U1, T1 > gleich false ist oder std:: is_convertible_v < U2, T2 > gleich false ist.

Dieser Konstruktor ist als gelöscht definiert, wenn die Initialisierung von first oder second eine Referenz an ein temporäres Objekt binden würde.

(since C++23)
4) Initialisiert first mit p. first und second mit p. second .
Dieser Konstruktor nimmt an der Überladungsauflösung teil, genau dann wenn std:: is_constructible_v < T1, U1 & > und std:: is_constructible_v < T2, U2 & > beide true sind.
Dieser Konstruktor ist explicit genau dann, wenn std:: is_convertible_v < U1 & , T1 > gleich false ist oder std:: is_convertible_v < U2 & , T2 > gleich false ist.
Dieser Konstruktor ist als gelöscht definiert, wenn die Initialisierung von first oder second eine Referenz auf ein temporäres Objekt binden würde.
5) Initialisiert first mit p. first und second mit p. second .

Dieser Konstruktor nimmt an der Überladungsauflösung teil, genau dann wenn std:: is_constructible_v < T1, const U1 & > und std:: is_constructible_v < T2, const U2 & > beide true sind.

Dieser Konstruktor ist explicit genau dann wenn std:: is_convertible_v < const U1 & , T1 > false ist oder std:: is_convertible_v < const U2 & , T2 > false ist.

(since C++11)

Dieser Konstruktor ist als gelöscht definiert, wenn die Initialisierung von first oder second eine Referenz auf ein temporäres Objekt binden würde.

(since C++23)
6) Initialisiert first mit std:: forward < U1 > ( p. first ) und second mit std:: forward < U2 > ( p. second ) .
Dieser Konstruktor nimmt an der Überladungsauflösung teil, genau dann wenn std:: is_constructible_v < T1, U1 > und std:: is_constructible_v < T2, U2 > beide true sind.
Dieser Konstruktor ist explicit genau dann, wenn std:: is_convertible_v < U1, T1 > gleich false ist oder std:: is_convertible_v < U2, T2 > gleich false ist.

Dieser Konstruktor ist als gelöscht definiert, wenn die Initialisierung von first oder second eine Referenz an ein temporäres Objekt binden würde.

(since C++23)
7) Initialisiert first mit std:: forward < const U1 > ( p. first ) und second mit std:: forward < const U2 > ( p. second ) .
Dieser Konstruktor nimmt an der Überladungsauflösung teil, genau dann wenn std:: is_constructible_v < T1, U1 > und std:: is_constructible_v < T2, U2 > beide true sind.
Dieser Konstruktor ist explicit genau dann, wenn std:: is_convertible_v < const U1, T1 > gleich false ist oder std:: is_convertible_v < const U2, T2 > gleich false ist.
Dieser Konstruktor ist als gelöscht definiert, wenn die Initialisierung von first oder second eine Referenz auf ein temporäres Objekt binden würde.
8) Gegeben u1 als std :: get < 0 > ( std:: forward ( u ) ) und u2 als std :: get < 1 > ( std:: forward ( u ) ) , bezeichne ihre Typen als U1 und U2 entsprechend. Initialisiert first mit u1 und second mit u2 .
Dieser Konstruktor nimmt an der Überladungsauflösung teil, genau dann wenn
Dieser Konstruktor ist explicit genau dann, wenn std:: is_convertible_v < U1, T1 > false ist oder std:: is_convertible_v < U2, T2 > false ist.
Dieser Konstruktor ist als gelöscht definiert, wenn die Initialisierung von first oder second eine Referenz auf ein temporäres Objekt binden würde.
9) Leitet die Elemente von first_args an den Konstruktor von first weiter und leitet die Elemente von second_args an den Konstruktor von second weiter. Dies ist der einzige nicht-standardmäßige Konstruktor, der verwendet werden kann, um ein Paar nicht-kopierbarer und nicht-verschiebbarer Typen zu erstellen. Das Programm ist fehlerhaft, wenn first oder second eine Referenz ist und an ein temporäres Objekt gebunden wird.
10) Copy-Konstruktor wird implizit deklariert (until C++11) defaulted, und ist constexpr wenn das Kopieren beider Elemente die Anforderungen an constexpr-Funktionen erfüllt (since C++11) .
11) Der Move-Konstruktor ist standardmäßig vorgegeben und ist constexpr , wenn das Verschieben beider Elemente die Anforderungen an constexpr-Funktionen erfüllt.

Inhaltsverzeichnis

Parameter

x - Wert zur Initialisierung des ersten Elements dieses Paares
y - Wert zur Initialisierung des zweiten Elements dieses Paares
p - Paar von Werten zur Initialisierung beider Elemente dieses Paares
u - pair-like Objekt von Werten zur Initialisierung beider Elemente dieses Paares
first_args - Tupel von Konstruktorargumenten zur Initialisierung des ersten Elements dieses Paares
second_args - Tupel von Konstruktorargumenten zur Initialisierung des zweiten Elements dieses Paares

Exceptions

Wirft keine Ausnahmen, es sei denn, eine der angegebenen Operationen (z.B. Konstruktor eines Elements) wirft.

Beispiel

Diesen Code ausführen 
#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);
}

Mögliche Ausgabe: 

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

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 265 C++98 der Standardkonstruktor initialisierte first
und second kopierend mit T1 ( ) und T2 ( ) entsprechend
(erforderte somit, dass T1 und T2 CopyConstructible sind) 		first und second
werden wertinitialisiert
LWG 2510 C++11 der Standardkonstruktor war implizit wurde bedingt-explizit gemacht
N4387 C++11 einige Konstruktoren waren nur implizit, was bestimmte Verwendungen verhinderte Konstruktoren wurden bedingt-explizit gemacht

Siehe auch

erstellt ein pair -Objekt vom Typ, bestimmt durch die Argumenttypen
(Funktions-Template)
konstruiert ein neues tuple
(öffentliche Mitgliedsfunktion von std::tuple<Types...> )