pair, structure

Article
10/12/2023

Struct qui offre la possibilité de traiter deux objets comme un objet unique.

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>;

Paramètres

Val1
Valeur initialisant le premier élément de pair.

Val2
Valeur initialisant le second élément de pair.

Right
Paire dont les valeurs doivent être utilisées pour initialiser les éléments d'une autre paire.

Valeur de retour

Le premier constructeur (par défaut) initialise le premier élément de la paire avec la valeur par défaut du type T1 et le deuxième élément par défaut de type T2. Elle est définie si les deux types sont constructibles par défaut.

Le deuxième constructeur initialise le premier élément de la paire à Val1 et le second à Val2. Elle est définie si les deux types sont constructibles de copie.

Le troisième constructeur (modèle) initialise le premier élément de la paire sur Right. d’abord et le second à Right. second. Elle est définie si les deux types de la paire sont constructibles à partir des types valeur fournis.

Le quatrième constructeur initialise le premier élément de la paire à Val1 et le second à Val2 à l’aide du déclarateur de référence Rvalue : &>. Elle est définie si les deux types de la paire sont constructibles à partir des types valeur fournis.

Notes

Le struct de modèle stocke une paire d’objets de type T1 et T2, respectivement. Le type first_type est identique au paramètre T1 de modèle et le type second_type est identique au paramètre T2de modèle. T1 et T2 chacun d’eux n’a besoin que d’un constructeur par défaut, d’un constructeur à argument unique et d’un destructeur. Tous les membres du type pair sont publics, car le type est déclaré comme un struct plutôt que comme un class. Les deux utilisations les plus courantes pour une paire sont en tant que types de retour pour des fonctions qui retournent deux valeurs et en tant qu’éléments pour les classes de conteneurs associatifs (classe map et classe multimap) qui ont à la fois une clé et un type de valeur associés à chaque élément. Ce dernier répond aux exigences d’un conteneur associatif pair et a un type valeur du formulaire pair< const key_type, mapped_type >.

Exemple

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

Partage via