de.cppreference.net

Namespaces

Page

Variants

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

Aus de.cppreference.net

< cpp | utility | pair

pair();	(1)	(constexpr seit C++11) (bedingt explizit seit C++11)
pair( const T1& x, const T2& y );	(2)	(constexpr seit C++14) (bedingt explizit seit C++11)
template< class U1, class U2 > pair( U1&& x, U2&& y );	(3)	(seit C++11) (constexpr seit C++14) (bis C++23) (bedingt explizit)
template< class U1 = T1, class U2 = T2 > constexpr pair( U1&& x, U2&& y );	(3)		(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)	(constexpr seit C++14) (bedingt explizit seit C++11)
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 pair.

1) Standardkonstruktor. Wertinitialisiert beide Elemente des pair, 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 default-konstruierbar ist.

(seit 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 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> false 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 an ein temporäres Objekt binden würde.

(seit 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> false 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 an 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 oder std::is_convertible_v<const U2&, T2> false ist.

(seit C++11)

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

(seit 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> false 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 an ein temporäres Objekt binden würde.

(seit 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> false oder std::is_convertible_v<const U2, T2> 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.

8) Gegeben u1 als std::get<0>(std::forward(u)) und u2 als std::get<1>(std::forward(u)), bezeichne deren Typen als U1 bzw. U2. Initialisiert first mit u1 und second mit u2.

Dieser Konstruktor nimmt an der Überladungsauflösung teil genau dann, wenn

std::remove_cvref(P) keine Spezialisierung von std::ranges::subrange ist,
std::is_constructible_v<T1, U1> true ist, und
std::is_constructible_v<T2, U2 true ist.

Dieser Konstruktor ist explicit genau dann, wenn std::is_convertible_v<U1, T1> false 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 an 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 pair aus nicht-kopierbaren, nicht-verschiebbaren Typen zu erstellen. Das Programm ist fehlerhaft, wenn first oder second eine Referenz ist und an ein temporäres Objekt gebunden wird.

10) Der Kopierkonstruktor ist implizit deklariert(bis C++11)defaulted, und ist constexpr, wenn das Kopieren beider Elemente die Anforderungen an constexpr-Funktionen erfüllt(seit C++11).

11) Der Verschiebekonstruktor ist defaulted, und ist constexpr, wenn das Verschieben beider Elemente die Anforderungen an constexpr-Funktionen erfüllt.

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

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