pair – struktura

Struktura, která poskytuje schopnost nakládat se dvěma objekty jako s jedním objektem.

Syntaxe

struct pair
{
    typedef T1 first_type;
    typedef T2 second_type;
    T1 first;
    T2 second;
    constexpr pair();
    pair(const pair&) = default;
    pair(pair&&) = default;
    constexpr pair(
        const T1& Val1,
        const T2& Val2);

    template <class Other1, class Other2>
    constexpr pair(const pair<Other1, Other2>& Right);

    template <class Other1, class Other2>
    constexpr pair(const pair <Other1 Val1, Other2 Val2>&& Right);

    template <class Other1, class Other2>
    constexpr pair(Other1&& Val1, Other2&& Val2);

    template <class... Args1, class... Args2>
    pair(piecewise_construct_t, tuple<Args1...> first_args, tuple<Args2...> second_args);

    pair& operator=(const pair& p);
    template<class U1, class U2> pair& operator=(const pair<U1, U2>& p);
    pair& operator=(pair&& p) noexcept(see below );
    template<class U1, class U2> pair& operator=(pair<U1, U2>&& p);

    void swap(pair& p) noexcept(see below );
};

template<class T1, class T2>
    pair(T1, T2) -> pair<T1, T2>;

Parametry

Val1
Hodnota inicializuje první prvek .pair

Val2
Hodnota inicializuje druhý prvek .pair

Right
Dvojice, jejíž hodnoty se mají použít k inicializaci prvků jiné dvojice.

Návratová hodnota

První (výchozí) konstruktor inicializuje první prvek dvojice na výchozí typ T1 a druhý prvek na výchozí typ T2. Je definován, pokud oba typy jsou výchozí-konstruktovatelné.

Druhý konstruktor inicializuje první prvek dvojice na Val1 a druhý na Val2. Je definován, pokud oba typy jsou copy-constructible.

Třetí konstruktor (šablona) inicializuje první prvek dvojice na Right. první a druhý až Right. druhý. Je definována, pokud jsou oba typy dvojice konstruktovatelné z zadaných typů hodnot.

Čtvrtý konstruktor inicializuje první prvek dvojice na Val1 a druhý do Val2 pomocí Deklarátoru Rvalue Reference: &&. Je definována, pokud jsou oba typy dvojice konstruktovatelné z zadaných typů hodnot.

Poznámky

Struktura šablony ukládá dvojici objektů typu T1 a T2v uvedeném pořadí. Typ first_type je stejný jako parametr T1 šablony a typ second_type je stejný jako parametr T2šablony . T1 a T2 každý z nich musí zadat pouze výchozí konstruktor, konstruktor s jedním argumentem a destruktor. Všechny členy typu pair jsou veřejné, protože typ je deklarován jako spíše struct než jako .class Dvěma nejběžnějšími způsoby použití páru jsou návratové typy pro funkce, které vracejí dvě hodnoty, a jako prvky pro asociativní třídy kontejneru map Třídy a multimap Třídy , které mají klíč i typ hodnoty přidružený k jednotlivým prvkům. Ten splňuje požadavky na asociativní kontejner páru a má typ hodnoty formuláře pair< const key_type, mapped_type >.

Příklad

// utility_pair.cpp
// compile with: /EHsc
#include <utility>
#include <map>
#include <iomanip>
#include <iostream>

int main( )
{
   using namespace std;

   // Using the constructor to declare and initialize a pair
   pair <int, double> p1 ( 10, 1.1e-2 );

   // Compare using the helper function to declare and initialize a pair
   pair <int, double> p2;
   p2 = make_pair ( 10, 2.22e-1 );

   // Making a copy of a pair
   pair <int, double> p3 ( p1 );

   cout.precision ( 3 );
   cout << "The pair p1 is: ( " << p1.first << ", "
        << p1.second << " )." << endl;
   cout << "The pair p2 is: ( " << p2.first << ", "
        << p2.second << " )." << endl;
   cout << "The pair p3 is: ( " << p3.first << ", "
        << p3.second << " )." << endl;

   // Using a pair for a map element
   map <int, int> m1;
   map <int, int>::iterator m1_Iter;

   typedef pair <int, int> Map_Int_Pair;

   m1.insert ( Map_Int_Pair ( 1, 10 ) );
   m1.insert ( Map_Int_Pair ( 2, 20 ) );
   m1.insert ( Map_Int_Pair ( 3, 30 ) );

   cout << "The element pairs of the map m1 are:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " ( " << m1_Iter -> first << ", "
           << m1_Iter -> second << " )";
   cout   << "." << endl;

   // Using pair as a return type for a function
   pair< map<int,int>::iterator, bool > pr1, pr2;
   pr1 = m1.insert ( Map_Int_Pair ( 4, 40 ) );
   pr2 = m1.insert ( Map_Int_Pair (1, 10 ) );

   if( pr1.second == true )
   {
      cout << "The element (4,40) was inserted successfully in m1."
           << endl;
   }
   else
   {
      cout << "The element with a key value of\n"
           << " ( (pr1.first) -> first ) = " << ( pr1.first ) -> first
           << " is already in m1,\n so the insertion failed." << endl;
   }

   if( pr2.second == true )
   {
      cout << "The element (1,10) was inserted successfully in m1."
           << endl;
   }
   else
   {
      cout << "The element with a key value of\n"
           << " ( (pr2.first) -> first ) = " << ( pr2.first ) -> first
           << " is already in m1,\n so the insertion failed." << endl;
   }
}

The pair p1 is: ( 10, 0.011 ).
The pair p2 is: ( 10, 0.222 ).
The pair p3 is: ( 10, 0.011 ).
The element pairs of the map m1 are: ( 1, 10 ) ( 2, 20 ) ( 3, 30 ).
The element (4,40) was inserted successfully in m1.
The element with a key value of
( (pr2.first) -> first ) = 1 is already in m1,
so the insertion failed.