tuple_element (Clase)

Contiene un elemento tuple . Las especializaciones contienen elementos array y elementos pair.

Sintaxis

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

Parámetros

Índice
Índice del elemento designado.

Tuple
El tipo de tupla.

Elem
El tipo de un elemento de matriz.

Tamaño
Se refiere al tamaño de la matriz.

T1
El tipo del primer elemento de un par.

T2
El tipo del segundo elemento de un par.

Comentarios

La clase de plantilla tuple_element tiene una definición de tipo anidada type que es un sinónimo del tipo en el índice Index del tipo de tupla Tuple.

La definición de tipo tuple_element_t es un alias adecuado para tuple_element<Index, Tuple>::type.

La especialización de la clase de plantilla para matrices proporciona una interfaz a un array como una tupla de elementos Size, cada uno con el mismo tipo. Cada especialización tiene una definición de tipo anidada type que es un sinónimo del tipo de elemento Index de la array, con las calificaciones const o volatile conservadas.

Las especializaciones de plantilla para tipos pair tienen una definición de tipo de miembro único, type, que es un sinónimo del tipo del elemento en la posición especificada en el par, con cualquier calificador const o volatile conservado. La definición de tipo tuple_element_t es un alias adecuado para tuple_element<N, pair<T1, T2>>::type.

Use la función get para devolver el elemento en una posición especificada o de un tipo especificado.

Ejemplo: obtener un elemento de una tupla

#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

Ejemplo: obtener un elemento de una matriz

#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

Ejemplo: obtener un elemento de una par

#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

Requisitos

Encabezado:<tuple>

Encabezado:<array> (para la especialización de matrices)

Encabezado:<utility> (para la especialización de pares)

Espacio de nombres: std