Espaces de noms
Variantes
Affichages
Actions

std::pair::pair

De cppreference.com
< cpp‎ | utility‎ | pair
 
 
 
std::pair
Les fonctions membres
Original:
Member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
pair::pair
pair::operator=
pair::swap
Tiers fonctions
Original:
Non-member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
make_pair
operator=
operator!=
operator<
operator<=
operator>
operator>=
std::swap
get (C++11)
Classes d'aide
Original:
Helper classes
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
tuple_size (C++11)
tuple_element (C++11)
 
pair();
constexpr pair();
(1) (avant C++11)
(depuis C++11)
pair( const T1& x, const T2& y );
(2)
template< class U1, class U2 >
pair( U1&& x, U2&& y );
(3) (depuis C++11)
template< class U1, class U2 >
pair( const pair<U1,U2>& p );
(4)
template< class U1, class U2 >
pair( pair<U1,U2>&& p );
(5) (depuis C++11)
template< class... Args1, class... Args2 >

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

      std::tuple<Args2...> second_args );
(6) (depuis C++11)
pair( const pair& p ) = default;
(7)
pair( pair&& p ) = default;
(8) (depuis C++11)


Construit une nouvelle paire

1) Constructeur par défaut. Initialise la valeur des deux éléments de la paire, first et second.

2) Initialise first avec x et second avec y.

3) Initialise first avec std::forward<U1>(x) et second avec std::forward<U2>(y).

4) Initialise first avec p.first et second avec p.second.

5) Initialise first avec std::move<U1>(p.first) et second avec std::move<U2>(p.second).

6) Transmet les éléments de first_args au constructeur de first et transmet les éléments de second_args au constructeur de second. C'est le seul constructeur autre que celui par défaut qui peut être utilisé pour créer une paire de types non copiables et non déplaçables.

7) Le constructeur de copie est implicitement généré.

8) Le constructeur de déplacement est implicitement généré

[modifier] Paramètres

x - Valeur utilisée pour initialiser le premier élément de cette paire
y - Valeur utilisée pour initialiser le second élément de cette paire
p - Combinaison de valeurs utilisées pour initialiser les éléments de cette paire
first_args - Tuple d'arguments passés au constructeur du premier élément de cette paire
second_args - Tuple d'arguments passés au constructeur du second élément de cette paire


[modifier] Exemple

#include <utility>
#include <string>
#include <complex>
#include <tuple>
#include <iostream>
int main()
{
    std::pair<int, float> p1;
    std::cout << "Value-initialized: "
              << p1.first << ", " << p1.second << '\n';
 
    std::pair<int, double> p2(42, 0.123);
    std::cout << "Initialized with two values: "
              << p2.first << ", " << p2.second << '\n';
 
    std::pair<char, int> p4(p2);
    std::cout << "Implicitly converted: "
              << p4.first << ", " << p4.second << '\n';
 
    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'));
    std::cout << "Piecewise constructed: "
              << p6.first << ", " << p6.second << '\n';
}

Résultat :

Value-initialized: 0, 0
Initialized with two values: 42, 0.123
Implicitly converted: *, 0
Piecewise constructed: (0.123,7.7), aaaaaaaaaa

[modifier] Voir aussi

crée un objet de type pair, définie par le type des arguments
Original:
creates a pair object of type, defined by the argument types
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction générique) [edit]