pair — Struktura

Struktura zapewniająca możliwość traktowania dwóch obiektów jako pojedynczego obiektu.

Składnia

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
Wartość inicjując pierwszy element elementu pair.

Val2
Wartość inicjując drugi element elementu pair.

Right
Para, której wartości mają być używane do inicjowania elementów innej pary.

Wartość zwracana

Pierwszy (domyślny) konstruktor inicjuje pierwszy element pary do wartości domyślnej typu T1 , a drugi element do domyślnego typu T2. Jest on definiowany, jeśli oba typy są domyślnie skonstruowane.

Drugi konstruktor inicjuje pierwszy element pary do Val1 , a drugi do Val2. Jest on zdefiniowany, jeśli oba typy są konstruowalne.

Trzeci (szablon) konstruktor inicjuje pierwszy element pary na Right. pierwszy i drugi do Right. drugi. Jest on zdefiniowany, jeśli oba typy pary są konstruowane na podstawie podanych typów wartości.

Czwarty konstruktor inicjuje pierwszy element pary do Val1 , a drugi do Val2 przy użyciu deklaratora odwołania Rvalue: &&. Jest on zdefiniowany, jeśli oba typy pary są konstruowane na podstawie podanych typów wartości.

Uwagi

Struktura szablonu przechowuje odpowiednio parę obiektów typu T1 i T2. Typ first_type jest taki sam jak parametr T1 szablonu, a typ second_type jest taki sam jak parametr T2szablonu . T1 każda T2 z nich wymaga podania tylko konstruktora domyślnego, konstruktora pojedynczego argumentu i destruktora. Wszystkie elementy członkowskie typu pair są publiczne, ponieważ typ jest zadeklarowany jako a struct , a nie jako class. Dwa najbardziej typowe zastosowania dla pary to typy zwracane dla funkcji, które zwracają dwie wartości i jako elementy dla klas kontenerów asocjacyjnych mapują klasę kontenerów i klasę wielomapową, która ma zarówno klucz, jak i typ wartości skojarzony z każdym elementem. Ten ostatni spełnia wymagania dotyczące kontenera asocjacji pary i ma typ wartości formularza pair< const key_type, mapped_type >.

Przykład

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