Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
apply
template <class F, class Tuple> constexpr decltype(auto) apply(F&& f, Tuple&& t);
Hinweise
Ruft Funktion F mit einem Tupel t auf.
forward_as_tuple
template <class... TTypes>
constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&...) noexcept;
Rückgabewert
Gibt tuple<TTypes&&...>(std::forward<TTypes>(t)...) zurück.
Hinweise
Erstellt ein Tupel von Verweisen auf die Argumente in t , die für die Weiterleitung als Argumente an eine Funktion geeignet sind.
get
Ruft ein Element aus einem tuple -Objekt nach dem Index oder (in C++14) nach dem Typ ab.
// by index:
// get reference to Index element of tuple
template <size_t Index, class... Types>
constexpr tuple_element_t<Index, tuple<Types...>>& get(tuple<Types...>& Tuple) noexcept;
// get const reference to Index element of tuple
template <size_t Index, class... Types>
constexpr const tuple_element_t<Index, tuple<Types...>>& get(const tuple<Types...>& Tuple) noexcept;
// get rvalue reference to Index element of tuple
template <size_t Index, class... Types>
constexpr tuple_element_t<Index, tuple<Types...>>&& get(tuple<Types...>&& Tuple) noexcept;
// (C++14) by type:
// get reference to T element of tuple
template <class T, class... Types>
constexpr T& get(tuple<Types...>& Tuple) noexcept;
// get const reference to T element of tuple
template <class T, class... Types>
constexpr const T& get(const tuple<Types...>& Tuple) noexcept;
// get rvalue reference to T element of tuple
template <class T, class... Types>
constexpr T&& get(tuple<Types...>&& Tuple) noexcept;
Parameter
Index
Der Index des abzurufenden Elements.
Typen
Die Sequenz der im Tupel deklarierten Typen in der Deklarationsreihenfolge.
T
Der Typ des abzurufenden Elements.
Tuple
A std::tuple , das eine beliebige Anzahl von Elementen enthält.
Hinweise
Die Vorlagenfunktionen geben einen Verweis auf den Wert im Indexindex oder vom Typ T im tuple Objekt zurück.
Das Aufrufen von get<T>(Tuple) führt zu einem Compilerfehler, wenn das Tupel mehr oder weniger als ein Element vom Typ T enthält.
Beispiel
#include <tuple>
#include <iostream>
#include <string>
using namespace std;
int main() {
tuple<int, double, string> tup(0, 1.42, "Call me Tuple");
// get elements by index
cout << " " << get<0>(tup);
cout << " " << get<1>(tup);
cout << " " << get<2>(tup) << endl;
// get elements by type
cout << " " << get<int>(tup);
cout << " " << get<double>(tup);
cout << " " << get<string>(tup) << endl;
}
0 1.42 Call me Tuple
0 1.42 Call me Tuple
make_from_tuple
template <class T, class Tuple> constexpr T make_from_tuple(Tuple&& t);
Hinweise
Wie in return make_from_tuple_impl<T>(forward<Tuple>(t), make_index_sequence<tuple_size_v<decay_t<Tuple>>>{}).
make_tuple
Erstellt eine tuple aus Elementwerten.
template <class T1, class T2, ..., class TN>
tuple<V1, V2, ..., VN> make_tuple(const T1& t1, const T2& t2, ..., const TN& tN);
Parameter
TN
Der Typ des Parameters der Nth-Funktion.
Tn
Der Wert des Parameters der Nth-Funktion.
Hinweise
Die Vorlagenfunktion gibt zurücktuple<V1, V2, ..., VN>(t1, t2, ..., tN), wobei jeder Typ Vi den entsprechenden Typ Ti aufweist reference_wrapper<X>X& cv; andernfalls ist Tisie .
Ein Vorteil von make_tuple ist, dass die Typen von Objekten, die gespeichert werden, automatisch vom Compiler bestimmt werden und nicht explizit angegeben werden müssen. Verwenden Sie keine expliziten Vorlagenargumente wie make_tuple<int, int>(1, 2), wenn Sie make_tuple verwenden, da dies unnötig detailliert ist und zu komplexen rvalue-Verweisproblemen führt, die möglicherweise Kompilierungsfehler verursachen.
Beispiel
// std__tuple__make_tuple.cpp
// compile by using: /EHsc
#include <tuple>
#include <iostream>
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::endl;
c0 = std::make_tuple(4, 5, 6, 7);
// display contents " 4 5 6 7"
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::endl;
return (0);
}
0 1 2 3
4 5 6 7
swap
template <class... Types>
void swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(see below );
tie
Erstellt eine tuple aus Elementverweisen.
template <class T1, class T2, ..., class TN>
tuple<T1&, T2&, ..., TN&> tie(T1& t1, T2& t2, ..., TN& tN);
Parameter
TN
Der Basistyp des N-ten Tupelelements.
Hinweise
Diese Vorlagenfunktion gibt tuple<T1&, T2&, ..., TN&>(t1, t2, ..., tN) zurück.
Beispiel
// std__tuple__tie.cpp
// compile with: /EHsc
#include <tuple>
#include <iostream>
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;
int v4 = 4;
double v5 = 5;
int v6 = 6;
double v7 = 7;
std::tie(v4, v5, v6, v7) = c0;
// display contents " 0 1 2 3"
std::cout << " " << v4;
std::cout << " " << v5;
std::cout << " " << v6;
std::cout << " " << v7;
std::cout << std::endl;
return (0);
}
0 1 2 3
0 1 2 3
tuple_cat
template <class... Tuples> constexpr tuple<CTypes...> tuple_cat(Tuples&&...);
Rückgabewert
Ein Tupelobjekt, das durch Initialisieren des einzelnen Typelements erstellt wird.
tuple_element_t
template <size_t I, class T>
using tuple_element_t = typename tuple_element<I, T>::type;
tuple_size_v
template <class T>
inline constexpr size_t tuple_size_v = tuple_size<T>::value;