tuple_element, classe

Article
10/12/2023

Encapsule un élément tuple . Les spécialisations encapsulent des éléments array et des éléments pair.

Syntaxe

// CLASS tuple_element (find element by index)
template <size_t Index, class Tuple>
   struct tuple_element;

// tuple_element for const
template <size_t Index, class Tuple>
   struct tuple_element<Index, const Tuple>;

// tuple_element for volatile
template <size_t Index, class Tuple>
   struct tuple_element<Index, volatile Tuple>;

// tuple_element for const volatile
template <size_t Index, class Tuple>
   struct tuple_element<Index, const volatile Tuple>;

// Helper typedef
template <size_t Index, class Tuple>
   using tuple_element_t = typename tuple_element<Index, Tuple>::type;

// Specialization for arrays
template <size_t Index, class Elem, size_t Size>
   struct tuple_element<Index, array<Elem, Size>>;

// Specializations for pairs
// struct to determine type of element 0 in pair
template <class T1, class T2>
   struct tuple_element<0, pair<T1, T2>>;

// struct to determine type of element 1 in pair
template <class T1, class T2>
   struct tuple_element<1, pair<T1, T2>>;

Paramètres

Index
Index de l’élément désigné.

Tuple
Type du tuple.

Elem
Type d’un élément de tableau.

Taille
Taille du tableau.

T1
Type du premier élément d’une paire.

T2
Le type du second élément d’une paire.

Notes

Le modèle tuple_element de classe a un typedef type imbriqué qui est un synonyme du type à l’index index du type tuple de type Tuple.

Le typedef tuple_element_t est un alias pratique pour tuple_element<Index, Tuple>::type.

La spécialisation de modèle de classe pour les tableaux fournit une interface à un array tuple d’éléments Size , chacun ayant le même type. Chaque spécialisation a un typedef type imbriqué qui est un synonyme du type de l’élément Index du array, avec toutes les qualifications const-volatiles conservées.

Les spécialisations de modèle pour les types pair fournissent chacune un typedef de membre unique, type, qui est un synonyme du type de l’élément à la position spécifiée dans la paire, avec des qualifications const et/ou volatiles conservées. Le typedef tuple_element_t est un alias pratique pour tuple_element<N, pair<T1, T2>>::type.

Utilisez la get fonction pour retourner l’élément à une position spécifiée ou d’un type spécifié.

Exemple : Obtenir un élément à partir d’un tuple

#include <tuple>
#include <string>
#include <iostream>

using namespace std;
typedef tuple<int, double, string> MyTuple;

int main() {
    MyTuple c0{ 0, 1.5, "Tail" };

    tuple_element_t<0, MyTuple> val = get<0>(c0); //get by index
    tuple_element_t<1, MyTuple> val2 = get<1>(c0);
    tuple_element_t<2, MyTuple> val3 = get<string>(c0); // get by type

    cout << val << " " << val2 << " " << val3 << endl;
}

0 1.5 Tail

Exemple : Obtenir un élément à partir d’un tableau

#include <array>
#include <iostream>

using namespace std;
typedef array<int, 4> MyArray;

int main()
{
    MyArray c0 { 0, 1, 2, 3 };

    for (const auto& e : c0)
    {
        cout << e << " ";
    }
    cout << endl;

    // display first element "0"
    tuple_element<0, MyArray>::type val = c0.front();
    cout << val << endl;
}

0 1 2 3
0

Exemple : Obtenir un élément à partir d’une paire

#include <utility>
#include <iostream>

using namespace std;

typedef pair<int, double> MyPair;
int main() {
    MyPair c0(0, 1.333);

    // display contents "0 1"
    cout << get<0>(c0) << " ";
    cout << get<1>(c0) << endl;

    // display first element "0 " by index
    tuple_element<0, MyPair>::type val = get<0>(c0);
    cout << val << " ";

    // display second element by type
    tuple_element<1, MyPair>::type val2 = get<double>(c0);
    cout << val2 << endl;
}

0 1.333
0 1.333

Spécifications

Header :<tuple>

Header :<array (pour la spécialisation de> tableau)

Header :<utility> (pour les spécialisations de paire)

Espace de noms : std

Partager via