fonctions<tuple>
apply
template <class F, class Tuple> constexpr decltype(auto) apply(F&& f, Tuple&& t);
Notes
Appelle la fonction F avec un tuple t.
forward_as_tuple
template <class... TTypes>
constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&...) noexcept;
Valeur de retour
Retourne tuple<TTypes&&...>(std::forward<TTypes>(t)...)
.
Notes
Construit un tuple de références aux arguments dans t adapté au transfert en tant qu’arguments vers une fonction.
get
Obtient un élément d’un objet tuple
, par index ou par type (dans C++14).
// 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;
Paramètres
Index
Index de l’élément à obtenir.
Types
Séquence de types déclarés dans le tuple dans l’ordre de déclaration.
T
Type de l’élément à obtenir.
Tuple
Qui std::tuple
contient un nombre quelconque d’éléments.
Notes
Les fonctions de modèle retournent une référence à la valeur à index Index ou de type T dans l’objettuple
.
L'appel de get<T>(Tuple)
génère une erreur de compilation si le Tuple ne contient pas un seul élément de type T.
Exemple
#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);
Notes
Comme pour return make_from_tuple_impl<T>(forward<Tuple>(t), make_index_sequence<tuple_size_v<decay_t<Tuple>>>{})
.
make_tuple
Crée un tuple
à partir des valeurs de l’élément.
template <class T1, class T2, ..., class TN>
tuple<V1, V2, ..., VN> make_tuple(const T1& t1, const T2& t2, ..., const TN& tN);
Paramètres
AMT
Type du N-ième paramètre de fonction.
Amt
Valeur du N-ième paramètre de fonction.
Notes
La fonction de modèle retourne tuple<V1, V2, ..., VN>(t1, t2, ..., tN)
, où chaque type Vi
est X&
lorsque le type correspondant Ti
est cv
reference_wrapper<X>
; sinon, il est Ti
.
Un avantage de make_tuple
est que les types d'objets stockés sont déterminés automatiquement par le compilateur et ne sont pas tenus d'être spécifiés explicitement. N'utilisez pas d'arguments template explicites, tels que make_tuple<int, int>(1, 2)
, lorsque vous utilisez make_tuple
, car cela est inutilement détaillé et ajoute des problèmes complexes de référence rvalue susceptibles de provoquer un échec de compilation.
Exemple
// 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
Crée un tuple
à partir des références d’élément.
template <class T1, class T2, ..., class TN>
tuple<T1&, T2&, ..., TN&> tie(T1& t1, T2& t2, ..., TN& tN);
Paramètres
AMT
Type de base du N-ième élément de tuple.
Notes
La fonction de modèle retourne tuple<T1&, T2&, ..., TN&>(t1, t2, ..., tN)
.
Exemple
// 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&&...);
Valeur de retour
Objet tuple construit en initialisant chaque élément de type.
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;
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultezEnvoyer et afficher des commentaires pour