std::tuple::tuple

<metanoindex/>

 

C++

Langage

Concepts

Bibliothèque d'utilitaires

Bibliothèque pour les chaînes de caractères

Bibliothèque de conteneurs

Bibliothèque d'algorithmes

Bibliothèque d'itérateurs

Bibliothèque pour le calcul numérique

Bibliothèque pour les entrées/sorties

Bibliothèque pour la régionalisation

Bibliothèque pour les expressions régulières (C++11)

Bibliothèque pour les opérations atomiques (C++11)

Bibliothèque pour les processus légers (threads) (C++11)

 

Bibliothèque d'utilitaires

Soutien des types fondamentaux (basic types, RTTI, type traits)

Gestion dynamique de la mémoire

Gestion d'erreur

Soutien à l'exécution

Fonctions variadic

Date et heure

Foncteurs

initializer_list (C++11)

bitset

hash (C++11)

Opérateurs relationnels

rel_ops::operator!= rel_ops::operator> rel_ops::operator<= rel_ops::operator>=

Paires et tuples

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

swap, forward et move

swap

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

declval (C++11)

 

std::tuple

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.

tuple::tuple

tuple::operator=

tuple::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_tuple

tie

forward_as_tuple

None

operator= operator!= operator< operator<= operator> operator>=

std::swap

get

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

tuple_element

uses_allocator

ignore

 

<tbody> </tbody>

Déclaré dans l'en-tête <tuple>
constexpr tuple();	(1)	(depuis C++11)
explicit tuple( const Types&... args );	(2)	(depuis C++11)
template< class... UTypes > explicit tuple( UTypes&&... args );	(3)	(depuis C++11)
template< class... UTypes > tuple( const tuple<UTypes...>& other );	(4)	(depuis C++11)
template <class... UTypes> tuple( tuple<UTypes...>&& other );	(5)	(depuis C++11)
template< class U1, class U2 > tuple( const pair<U1,U2>& p );	(6)	(depuis C++11)
template< class U1, class U2 > tuple( pair<U1,U2>&& p );	(7)	(depuis C++11)
tuple( const tuple& other ) = default;	(8)	(depuis C++11)
tuple( tuple&& other ) = default;	(9)	(depuis C++11)
template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a );	(10)	(depuis C++11)
template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, const Types&... args );	(11)	(depuis C++11)
template< class Alloc, class... UTypes > tuple( std::allocator_arg_t, const Alloc& a, UTypes&&... args );	(12)	(depuis C++11)
template <class Alloc, class... UTypes> tuple( std::allocator_arg_t, const Alloc& a, const tuple<UTypes...>& other );	(13)	(depuis C++11)
template< class Alloc, class... UTypes > tuple( std::allocator_arg_t, const Alloc& a, tuple<UTypes...>&& other );	(14)	(depuis C++11)
template< class Alloc, class U1, class U2 > tuple( std::allocator_arg_t, const Alloc& a, const pair<U1, U2>& p );	(15)	(depuis C++11)
template< class Alloc, class U1, class U2 > tuple( std::allocator_arg_t, const Alloc& a, pair<U1, U2>&& p );	(16)	(depuis C++11)
template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, const tuple& other );	(17)	(depuis C++11)
template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, tuple&& other );	(18)	(depuis C++11)

Construit un nouveau tuple .

Original:

Constructs a new tuple.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

1)

Constructeur par défaut. Valeur-initialise tous les éléments .

Original:

Default constructor. Value-initializes all elements.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

2)

Initialise chaque élément de l'uplet avec le paramètre correspondant .

Original:

Initializes each element of the tuple with the corresponding parameter.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

3)

Initialise chaque élément du tuple avec la valeur correspondante dans std::forward<Utypes>(args) .

Original:

Initializes each element of the tuple with the corresponding value in std::forward<Utypes>(args).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

4)

Pour tous i dans sizeof...(UTypes), initialise ième élément du tuple avec std::get<i>(other) .

Original:

For all i in sizeof...(UTypes), initializes ith element of the tuple with std::get<i>(other).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

5)

Pour tous i dans sizeof...(UTypes), initialise ième élément du tuple avec std::forward<Ui>(std::get<i>(other)) .

Original:

For all i in sizeof...(UTypes), initializes ith element of the tuple with std::forward<Ui>(std::get<i>(other)).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

6)

Construit un tuple 2-élément avec le premier élément de construction à partir de p.first et le second élément de p.second

Original:

Constructs a 2-element tuple with the first element constructed from p.first and the second element from p.second

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

7)

Construit un tuple 2-élément avec le premier élément de construction à partir de std::forward<U1>(p.first) et le second élément de std::forward<U2>(p.second)

Original:

Constructs a 2-element tuple with the first element constructed from std::forward<U1>(p.first) and the second element from std::forward<U2>(p.second)

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

8)

Le compilateur a généré constructeur de copie. Initialise chaque élément de l'uplet avec l'élément correspondant de other

Original:

Compiler-generated copy constructor. Initializes each element of the tuple with the corresponding element of other

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

9)

Le compilateur a généré constructeur déménagement. Initialise chaque i-ème élément du tuple avec std::forward<Ui>(std::get<i>(other)) .

Original:

Compiler-generated move constructor. Initializes each ith element of the tuple with std::forward<Ui>(std::get<i>(other)).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

10 à 18) Identique à 1-9 sauf que chaque élément est créé par' utilisation de la construction-allocateur, qui est, le a objet allocateur est passé comme un argument supplémentaire pour le constructeur de chaque élément pour lequel std::uses_allocator<Ui, Alloc>::value est true .

Original:

10 - 18) Identical to 1-9 except each element is created by uses-allocator construction, that is, the Allocator object a is passed as an additional argument to the constructor of each element for which std::uses_allocator<Ui, Alloc>::value is true.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Paramètres

args	-	valeurs utilisées pour initialiser chaque élément du tuple Original: values used to initialize each element of the tuple The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
other	-	un n-uplet de valeurs utilisées pour initialiser chaque élément de la tupe Original: a tuple of values used to initialize each element of the tupe The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
p	-	Combinaison de valeurs utilisées pour initialiser les éléments de ce 2-tuple Original: pair of values used to initialize both elements of this 2-tuple The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
a	-	allocateur à utiliser dans des utilisations-allocateur de construction Original: allocator to use in uses-allocator construction The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Exemple

#include <iostream>
#include <string>
#include <vector>
#include <tuple>
#include <memory>

// helper function to print a tuple of any size
template<class Tuple, std::size_t N>
struct TuplePrinter {
    static void print(const Tuple& t) 
    {
        TuplePrinter<Tuple, N-1>::print(t);
        std::cout << ", " << std::get<N-1>(t);
    }
};

template<class Tuple>
struct TuplePrinter<Tuple, 1>{
    static void print(const Tuple& t) 
    {
        std::cout << std::get<0>(t);
    }
};

template<class... Args>
void print(const std::tuple<Args...>& t) 
{
    std::cout << "(";
    TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
    std::cout << ")\n";
}
// end helper function

int main()
{
    std::tuple<int, std::string, double> t1;
    std::cout << "Value-initialized: "; print(t1);
    std::tuple<int, std::string, double> t2(42, "Test", -3.14);
    std::cout << "Initialized with values: "; print(t2);
    std::tuple<char, std::string, int> t3(t2);
    std::cout << "Implicitly converted: "; print(t3);
    std::tuple<int, double> t4(std::make_pair(42, 3.14));
    std::cout << "Constructed from a pair"; print(t4);

    // given Allocator my_alloc with a single-argument constructor my_alloc(int)
    // use my_alloc(1) to allocate 10 ints in a vector
    std::vector<int, my_alloc> v(10, 1, my_alloc(1));
    // use my_alloc(2) to allocate 10 ints in a vector in a tuple
    std::tuple<int, std::vector<int, my_alloc>, double> t5(std::allocator_arg,
                                                           my_alloc(2), 42, v,  -3.14);
}

Résultat :

Value-initialized: (0, , 0)
Initialized with values: (42, Test, -3.14)
Implicitly converted: (*, Test, -3)
Constructed from a pair(42, 3.14)

Voir aussi

make_tuple	crée un objet tuple du type défini par les types d'arguments Original: creates a tuple object of the 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)
tie	crée un tuple de références lvalue ou décompresse un tuple dans des objets individuels Original: creates a tuple of lvalue references or unpacks a tuple into individual objects 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)
forward_as_tuple	crée un tuple des références rvalue Original: creates a tuple of rvalue references 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)