tuple_element-Klasse

Umschließt ein tuple -Element. Spezialisierungen umschließen array-Elemente und pair-Elemente.

Syntax

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

Parameter

Index
Der Index des angegebenen Elements.

Tuple
Der Typ des Tupels.

Elem
Der Typ eines Arrayelements.

Größe
Die Größe des Arrays.

T1
Der Typ des ersten Elements in einem Paar.

T2
Der Typ des zweiten Elements in einem Paar.

Hinweise

Die Klassenvorlage tuple_element weist einen geschachtelten Typedef type auf, der ein Synonym für den Typ im Indexindex des Tupeltyps Tupel ist.

Das Typedef tuple_element_t ist ein zweckmäßiger Alias für tuple_element<Index, Tuple>::type.

Die Klassenvorlagenspezialisierung für Arrays stellt eine Schnittstelle zu einem array Tupel von Size Elementen bereit, die jeweils denselben Typ aufweisen. Jede Spezialisierung verfügt über einen geschachtelten Typedef type , der ein Synonym für den Typ des Indexelements des Ist-Elements arrayist, wobei alle veränderlichen Qualifikationen erhalten bleiben.

Die Vorlagenspezialisierungen für pair-Typen bieten eine einzelne Member-Typedef type an, die ein Synonym für den Typ des Elements an der angegebenen Position im Paar ist, wobei alle const- und/oder volatile-Qualifikationen beibehalten werden. Das Typedef tuple_element_t ist ein zweckmäßiger Alias für tuple_element<N, pair<T1, T2>>::type.

Verwenden Sie die get Funktion , um das Element an einer angegebenen Position oder einem angegebenen Typ zurückzugeben.

Beispiel: Abrufen eines Elements aus einem Tupel

#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

Beispiel: Abrufen eines Elements aus einem Array

#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

Beispiel: Abrufen eines Elements aus einem Paar

#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

Anforderungen

Header:<Tupel>

Header:<Array> (für Arrayspezialisierung)

Header:<utility> (für Paarspezialisierungen)

Namespace: std