Freigeben über

Tupelklasse

  • Artikel

Umschließt eine Sequenz von Elementen mit fester Länge.

Syntax

class tuple {
   tuple();
   explicit tuple(P1, P2, ..., PN); // 0 < N
   tuple(const tuple&);
   template <class U1, class U2, ..., class UN>
      tuple(const tuple<U1, U2, ..., UN>&);
   template <class U1, class U2>
      tuple(const pair<U1, U2>&); // N == 2

   void swap(tuple& right);
   tuple& operator=(const tuple&);
   template <class U1, class U2, ..., class UN>
      tuple& operator=(const tuple<U1, U2, ..., UN>&);
   template <class U1, class U2>
      tuple& operator=(const pair<U1, U2>&); // N == 2
};

Parameter

TN
Der Typ des N-ten Tupelelements.

Hinweise

Die Klassenvorlage beschreibt ein Objekt, in dem N-Objekte von Typen T1, ... T2TNbzw. wo 0 <= N <= Nmaxgespeichert werden. Der Umfang einer Tupelinstanz tuple<T1, T2, ..., TN> ist die Anzahl N der Vorlagenargumente. Der Index des Vorlagenarguments Ti und des entsprechenden gespeicherten Werts dieses Typs lautet i - 1. Während wir in dieser Dokumentation die Typen von 1 bis N nummerieren, reichen die entsprechenden Indexwerte von 0 bis N - 1.

Beispiel

// tuple.cpp
// compile with: /EHsc

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

using namespace std;

typedef tuple <int, double, string> ids;

void print_ids(const ids& i)
{
   cout << "( "
        << get<0>(i) << ", "
        << get<1>(i) << ", "
        << get<2>(i) << " )." << endl;
}

int main( )
{
   // Using the constructor to declare and initialize a tuple
   ids p1(10, 1.1e-2, "one");

   // Compare using the helper function to declare and initialize a tuple
   ids p2;
   p2 = make_tuple(10, 2.22e-1, "two");

   // Making a copy of a tuple
   ids p3(p1);

   cout.precision(3);
   cout << "The tuple p1 is: ( ";
   print_ids(p1);
   cout << "The tuple p2 is: ( ";
   print_ids(p2);
   cout << "The tuple p3 is: ( ";
   print_ids(p3);

   vector<ids> v;

   v.push_back(p1);
   v.push_back(p2);
   v.push_back(make_tuple(3, 3.3e-2, "three"));

   cout << "The tuples in the vector are" << endl;
   for(vector<ids>::const_iterator i = v.begin(); i != v.end(); ++i)
   {
      print_ids(*i);
   }
}

The tuple p1 is: ( 10, 0.011, one ).
The tuple p2 is: ( 10, 0.222, two ).
The tuple p3 is: ( 10, 0.011, one ).
The tuples in the vector are
( 10, 0.011, one ).
( 10, 0.222, two ).
( 3, 0.033, three ).

operator =

Weist ein tuple-Objekt zu.

tuple& operator=(const tuple& right);

template <class U1, class U2, ..., class UN>
   tuple& operator=(const tuple<U1, U2, ..., UN>& right);

template <class U1, class U2>
   tuple& operator=(const pair<U1, U2>& right); // N == 2

tuple& operator=(tuple&& right);

template <class U1, class U2>
   tuple& operator=(pair<U1, U2>&& right);

Parameter

UN
Der Typ des N-ten kopierten Tupelelements.

right
Das Tupel, aus dem kopiert werden soll.

Hinweise

Die ersten beiden Memberoperatoren weisen den entsprechenden Elementen *thisdas Recht zu. Der dritte Memberoperator weist dem Element am Index 0 von *thisright.first zu und dem Element am Index 1 right.second. Alle drei Memberoperatoren geben *this zurück.

Die restlichen Memberoperatoren sind analog zu früheren, aber mit Rvalue Reference Declarator: &&.

Beispiel

// std__tuple__tuple_operator_as.cpp
// compile with: /EHsc
#include <tuple>
#include <iostream>
#include <utility>

typedef std::tuple<int, double, int, double> Mytuple;
int main()
    {
    Mytuple c0(0, 1, 2, 3);

// display contents " 0 1 2 3"
    std::cout << " " << std::get<0>(c0);
    std::cout << " " << std::get<1>(c0);
    std::cout << " " << std::get<2>(c0);
    std::cout << " " << std::get<3>(c0);
    std::cout << std::endl;

    Mytuple c1;
    c1 = c0;

// display contents " 0 1 2 3"
    std::cout << " " << std::get<0>(c1);
    std::cout << " " << std::get<1>(c1);
    std::cout << " " << std::get<2>(c1);
    std::cout << " " << std::get<3>(c1);
    std::cout << std::endl;

    std::tuple<char, int> c2;
    c2 = std::make_pair('x', 4);

// display contents " x 4"
    std::cout << " " << std::get<0>(c2);
    std::cout << " " << std::get<1>(c2);
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0 1 2 3
x 4

swap

Tauscht die Elemente zweier Tupel aus.

template <class... Types>
   void swap(tuple<Types...&> left, tuple<Types...&> right);

Parameter

left
Ein Tupel, dessen Elemente mit denen des Tupels rechts ausgetauscht werden sollen.

right
Ein Tupel, dessen Elemente mit denen des Tupels links ausgetauscht werden sollen.

Hinweise

Die Funktion führt left.swap(right) aus.

tuple

Erstellt ein tuple-Objekt.

constexpr tuple();
explicit constexpr tuple(const Types&...);
template <class... UTypes>
   explicit constexpr tuple(UTypes&&...);

tuple(const tuple&) = default;
tuple(tuple&&) = default;

template <class... UTypes>
   constexpr tuple(const tuple<UTypes...>&);
template <class... UTypes>
   constexpr tuple(tuple<UTypes...>&&);

// only if sizeof...(Types) == 2
template <class U1, class U2>
   constexpr tuple(const pair<U1, U2>&);
template <class U1, class U2>
   constexpr tuple(pair<U1, U2>&&);

Parameter

UN
Der Typ des N-ten kopierten Tupelelements.

right
Das Tupel, aus dem kopiert werden soll.

Hinweise

Der erste Konstruktor erstellt ein Objekt, dessen Elemente standardmäßig erstellt werden.

Der zweite Konstruktor erstellt ein Objekt, dessen Elemente durch Kopieren aus den Argumenten P1, P2, ..., PN erstellt werden, wobei jedes Pi das Element initialisiert, das den Index i - 1 hat.

Die dritten und vierten Konstruktoren erstellen ein Objekt, dessen Elemente aus dem entsprechenden Element rechts kopiert werden.

Der fünfte Konstruktor erstellt ein Objekt, dessen Element bei Index 0 durch Kopieren aus right.first und dessen Element bei Index 1 durch Kopieren aus right.second erstellt wird.

Die restlichen Konstruktoren sind analog zu früheren, aber mit Rvalue Reference Declarator: &&.

Beispiel

// std__tuple__tuple_tuple.cpp
// compile with: /EHsc
#include <tuple>
#include <iostream>
#include <utility>

typedef std::tuple<int, double, int, double> Mytuple;
int main()
{
    Mytuple c0(0, 1, 2, 3);

    // display contents "0 1 2 3"
    std::cout << std::get<0>(c0) << " ";
    std::cout << std::get<1>(c0) << " ";
    std::cout << std::get<2>(c0) << " ";
    std::cout << std::get<3>(c0);
    std::cout << std::endl;

    Mytuple c1;
    c1 = c0;

    // display contents "0 1 2 3"
    std::cout << std::get<0>(c1) << " ";
    std::cout << std::get<1>(c1) << " ";
    std::cout << std::get<2>(c1) << " ";
    std::cout << std::get<3>(c1);
    std::cout << std::endl;

    std::tuple<char, int> c2(std::make_pair('x', 4));

    // display contents "x 4"
    std::cout << std::get<0>(c2) << " ";
    std::cout << std::get<1>(c2);
    std::cout << std::endl;

    Mytuple c3(c0);

    // display contents "0 1 2 3"
    std::cout << std::get<0>(c3) << " ";
    std::cout << std::get<1>(c3) << " ";
    std::cout << std::get<2>(c3) << " ";
    std::cout << std::get<3>(c3);
    std::cout << std::endl;

    typedef std::tuple<int, float, int, float> Mytuple2;
    Mytuple c4(Mytuple2(4, 5, 6, 7));

    // display contents "4 5 6 7"
    std::cout << std::get<0>(c4) << " ";
    std::cout << std::get<1>(c4) << " ";
    std::cout << std::get<2>(c4) << " ";
    std::cout << std::get<3>(c4);
    std::cout << std::endl;

    return (0);
}

0 1 2 3
0 1 2 3
x 4
0 1 2 3
4 5 6 7