Come si può iterare sugli elementi di uno std :: tupla?
https://stackoverflow.com/questions/1198260
-
20-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Come posso iterare su una tupla (utilizzando C ++ 11)? Ho provato quanto segue:
for(int i=0; i<std::tuple_size<T...>::value; ++i)
std::get<i>(my_tuple).do_sth();
, ma questo non funziona:
Errore 1: sorry, non implementata:. Non può espandersi ‘Listener ...’ in un elenco di argomenti di lunghezza fissa
Errore 2:. Non può apparire in un'espressione costante
Quindi, come faccio correttamente un'iterazione sugli elementi di una tupla?
Soluzione
Boost.Fusion è una possibilità:
Esempio testato:
struct DoSomething
{
template<typename T>
void operator()(T& t) const
{
t.do_sth();
}
};
tuple<....> t = ...;
boost::fusion::for_each(t, DoSomething());
Altri suggerimenti
Ho una risposta basata su Iterazione nel corso di un Tuple :
#include <tuple>
#include <utility>
#include <iostream>
template<std::size_t I = 0, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), void>::type
print(std::tuple<Tp...>& t)
{ }
template<std::size_t I = 0, typename... Tp>
inline typename std::enable_if<I < sizeof...(Tp), void>::type
print(std::tuple<Tp...>& t)
{
std::cout << std::get<I>(t) << std::endl;
print<I + 1, Tp...>(t);
}
int
main()
{
typedef std::tuple<int, float, double> T;
T t = std::make_tuple(2, 3.14159F, 2345.678);
print(t);
}
L'idea comune è quella di utilizzare tempo di compilazione ricorsione. In realtà, questa idea è usato per fare un printf che è di tipo sicuro come indicato nelle carte tuple originale.
Questo può essere facilmente generalizzato in un for_each per le tuple:
#include <tuple>
#include <utility>
template<std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), void>::type
for_each(std::tuple<Tp...> &, FuncT) // Unused arguments are given no names.
{ }
template<std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I < sizeof...(Tp), void>::type
for_each(std::tuple<Tp...>& t, FuncT f)
{
f(std::get<I>(t));
for_each<I + 1, FuncT, Tp...>(t, f);
}
Anche se questo poi richiede un certo sforzo per avere FuncT rappresentare qualcosa con i sovraccarichi appropriati per ogni tipo tupla potrebbe contenere. Questo funziona meglio se si conosce tutti gli elementi tupla condivideranno una classe base comune o qualcosa di simile.
In C ++ 17, è possibile utilizzare std::apply con piegare espressione :
std::apply([](auto&&... args) {((/* args.dosomething() */), ...);}, the_tuple);
Un esempio completo per la stampa di una tupla:
#include <tuple>
#include <iostream>
int main()
{
std::tuple t{42, 'a', 4.2}; // Another C++17 feature: class template argument deduction
std::apply([](auto&&... args) {((std::cout << args << '\n'), ...);}, t);
}
Questa soluzione risolve il problema di ordine di valutazione in M. di Alaggan risposta .
Usa Boost.Hana e lambda generico:
#include <tuple>
#include <iostream>
#include <boost/hana.hpp>
#include <boost/hana/ext/std/tuple.hpp>
struct Foo1 {
int foo() const { return 42; }
};
struct Foo2 {
int bar = 0;
int foo() { bar = 24; return bar; }
};
int main() {
using namespace std;
using boost::hana::for_each;
Foo1 foo1;
Foo2 foo2;
for_each(tie(foo1, foo2), [](auto &foo) {
cout << foo.foo() << endl;
});
cout << "foo2.bar after mutation: " << foo2.bar << endl;
}
In C ++ 17 si può fare questo:
std::apply([](auto ...x){std::make_tuple(x.do_something()...);} , the_tuple);
Questo funziona già in Clang ++ 3.9, utilizzando std :: :: sperimentale applicare.
È necessario utilizzare template metaprogrammazione, qui mostrato con Boost.Tuple:
#include <boost/tuple/tuple.hpp>
#include <iostream>
template <typename T_Tuple, size_t size>
struct print_tuple_helper {
static std::ostream & print( std::ostream & s, const T_Tuple & t ) {
return print_tuple_helper<T_Tuple,size-1>::print( s, t ) << boost::get<size-1>( t );
}
};
template <typename T_Tuple>
struct print_tuple_helper<T_Tuple,0> {
static std::ostream & print( std::ostream & s, const T_Tuple & ) {
return s;
}
};
template <typename T_Tuple>
std::ostream & print_tuple( std::ostream & s, const T_Tuple & t ) {
return print_tuple_helper<T_Tuple,boost::tuples::length<T_Tuple>::value>::print( s, t );
}
int main() {
const boost::tuple<int,char,float,char,double> t( 0, ' ', 2.5f, '\n', 3.1416 );
print_tuple( std::cout, t );
return 0;
}
In C ++ 0x, è possibile scrivere print_tuple() come una funzione template variadic invece.
C ++ introduce dichiarazioni espansione per questo scopo. Essi sono stati inizialmente in pista per C ++ 20, ma di poco mancato il taglio a causa della mancanza di tempo per la revisione lingua formulazione (vedi qui e qui ).
La sintassi attualmente concordato (vedi link sopra) è:
{
auto tup = std::make_tuple(0, 'a', 3.14);
template for (auto elem : tup)
std::cout << elem << std::endl;
}
In primo luogo definire alcuni aiutanti di indice:
template <size_t ...I>
struct index_sequence {};
template <size_t N, size_t ...I>
struct make_index_sequence : public make_index_sequence<N - 1, N - 1, I...> {};
template <size_t ...I>
struct make_index_sequence<0, I...> : public index_sequence<I...> {};
Con la funzione che si desidera applicare su ogni elemento tupla:
template <typename T>
/* ... */ foo(T t) { /* ... */ }
è possibile scrivere:
template<typename ...T, size_t ...I>
/* ... */ do_foo_helper(std::tuple<T...> &ts, index_sequence<I...>) {
std::tie(foo(std::get<I>(ts)) ...);
}
template <typename ...T>
/* ... */ do_foo(std::tuple<T...> &ts) {
return do_foo_helper(ts, make_index_sequence<sizeof...(T)>());
}
Se foo torna void, utilizzare
std::tie((foo(std::get<I>(ts)), 1) ... );
Nota: Il C ++ 14 make_index_sequence è già definita ( http: // it. cppreference.com/w/cpp/utility/integer_sequence ).
Se avete bisogno di un ordine di valutazione da sinistra a destra, prendere in considerazione qualcosa di simile:
template <typename T, typename ...R>
void do_foo_iter(T t, R ...r) {
foo(t);
do_foo(r...);
}
void do_foo_iter() {}
template<typename ...T, size_t ...I>
void do_foo_helper(std::tuple<T...> &ts, index_sequence<I...>) {
do_foo_iter(std::get<I>(ts) ...);
}
template <typename ...T>
void do_foo(std::tuple<T...> &ts) {
do_foo_helper(ts, make_index_sequence<sizeof...(T)>());
}
Un modo più semplice, intuitiva e compilatore-friendly di fare questo in C ++ 17, utilizzando if constexpr :
// prints every element of a tuple
template<size_t I = 0, typename... Tp>
void print(std::tuple<Tp...>& t) {
std::cout << std::get<I>(t) << " ";
// do things
if constexpr(I+1 != sizeof...(Tp))
print<I+1>(t);
}
Questa è compile-time ricorsione, simile a quello presentato da @emsr. Ma questo non fa uso di SFINAE quindi (credo) è più del compilatore-friendly.
Se si desidera utilizzare std :: tuple e si dispone di compilatore C ++ che supporta i modelli variadic, provare il codice soffietto (testato con g ++ 4.5). Questa dovrebbe essere la risposta alla tua domanda.
#include <tuple>
// ------------- UTILITY---------------
template<int...> struct index_tuple{};
template<int I, typename IndexTuple, typename... Types>
struct make_indexes_impl;
template<int I, int... Indexes, typename T, typename ... Types>
struct make_indexes_impl<I, index_tuple<Indexes...>, T, Types...>
{
typedef typename make_indexes_impl<I + 1, index_tuple<Indexes..., I>, Types...>::type type;
};
template<int I, int... Indexes>
struct make_indexes_impl<I, index_tuple<Indexes...> >
{
typedef index_tuple<Indexes...> type;
};
template<typename ... Types>
struct make_indexes : make_indexes_impl<0, index_tuple<>, Types...>
{};
// ----------- FOR EACH -----------------
template<typename Func, typename Last>
void for_each_impl(Func&& f, Last&& last)
{
f(last);
}
template<typename Func, typename First, typename ... Rest>
void for_each_impl(Func&& f, First&& first, Rest&&...rest)
{
f(first);
for_each_impl( std::forward<Func>(f), rest...);
}
template<typename Func, int ... Indexes, typename ... Args>
void for_each_helper( Func&& f, index_tuple<Indexes...>, std::tuple<Args...>&& tup)
{
for_each_impl( std::forward<Func>(f), std::forward<Args>(std::get<Indexes>(tup))...);
}
template<typename Func, typename ... Args>
void for_each( std::tuple<Args...>& tup, Func&& f)
{
for_each_helper(std::forward<Func>(f),
typename make_indexes<Args...>::type(),
std::forward<std::tuple<Args...>>(tup) );
}
template<typename Func, typename ... Args>
void for_each( std::tuple<Args...>&& tup, Func&& f)
{
for_each_helper(std::forward<Func>(f),
typename make_indexes<Args...>::type(),
std::forward<std::tuple<Args...>>(tup) );
}
boost :: fusione è un'altra opzione, ma richiede il proprio tipo tupla: boost :: :: fusione tuple. Consente meglio attenersi alla norma! Ecco un test:
#include <iostream>
// ---------- FUNCTOR ----------
struct Functor
{
template<typename T>
void operator()(T& t) const { std::cout << t << std::endl; }
};
int main()
{
for_each( std::make_tuple(2, 0.6, 'c'), Functor() );
return 0;
}
il potere di modelli variadic!
Ecco un semplice C ++ 17 modo di iterare su oggetti tupla con biblioteca solo standard:
#include <tuple> // std::tuple
#include <functional> // std::invoke
template <
size_t Index = 0, // start iteration at 0 index
typename TTuple, // the tuple type
size_t Size =
std::tuple_size_v<
std::remove_reference_t<TTuple>>, // tuple size
typename TCallable, // the callable to bo invoked for each tuple item
typename... TArgs // other arguments to be passed to the callable
>
void for_each(TTuple&& tuple, TCallable&& callable, TArgs&&... args)
{
if constexpr (Index < Size)
{
std::invoke(callable, args..., std::get<Index>(tuple));
if constexpr (Index + 1 < Size)
for_each<Index + 1>(
std::forward<TTuple>(tuple),
std::forward<TCallable>(callable),
std::forward<TArgs>(args)...);
}
}
Esempio:
#include <iostream>
int main()
{
std::tuple<int, char> items{1, 'a'};
for_each(items, [](const auto& item) {
std::cout << item << "\n";
});
}
Output:
1
a
Questo può essere esteso per rompere il ciclo condizionale nel caso in cui i rendimenti callable un valore (ma ancora lavorare con callable che non restituiscono un valore assegnabile bool, per esempio void):
#include <tuple> // std::tuple
#include <functional> // std::invoke
template <
size_t Index = 0, // start iteration at 0 index
typename TTuple, // the tuple type
size_t Size =
std::tuple_size_v<
std::remove_reference_t<TTuple>>, // tuple size
typename TCallable, // the callable to bo invoked for each tuple item
typename... TArgs // other arguments to be passed to the callable
>
void for_each(TTuple&& tuple, TCallable&& callable, TArgs&&... args)
{
if constexpr (Index < Size)
{
if constexpr (std::is_assignable_v<bool&, std::invoke_result_t<TCallable&&, TArgs&&..., decltype(std::get<Index>(tuple))>>)
{
if (!std::invoke(callable, args..., std::get<Index>(tuple)))
return;
}
else
{
std::invoke(callable, args..., std::get<Index>(tuple));
}
if constexpr (Index + 1 < Size)
for_each<Index + 1>(
std::forward<TTuple>(tuple),
std::forward<TCallable>(callable),
std::forward<TArgs>(args)...);
}
}
Esempio:
#include <iostream>
int main()
{
std::tuple<int, char> items{ 1, 'a' };
for_each(items, [](const auto& item) {
std::cout << item << "\n";
});
std::cout << "---\n";
for_each(items, [](const auto& item) {
std::cout << item << "\n";
return false;
});
}
Output:
1
a
---
1
tuple di spinta fornisce funzioni di supporto e get_head() get_tail() in modo che le funzioni di aiuto possono apparire in questo modo:
inline void call_do_sth(const null_type&) {};
template <class H, class T>
inline void call_do_sth(cons<H, T>& x) { x.get_head().do_sth(); call_do_sth(x.get_tail()); }
come descritto qui http: // www .boost.org / doc / librerie / 1_34_0 / librerie / tupla / doc / tuple_advanced_interface.html
con std::tuple dovrebbe essere simile.
In realtà, purtroppo std::tuple non sembra fornire tale interfaccia, in modo da metodi suggeriti prima dovrebbe funzionare, o si avrebbe bisogno di passare a boost::tuple che ha altri vantaggi (come gli operatori io già forniti). Anche se non v'è aspetto negativo di boost::tuple con gcc -. Non accetta i modelli variadic ancora, ma che può essere già fissato come non ho ultima versione di spinta installata sulla mia macchina
potrei aver perso questo treno, ma questo sarà per riferimenti futuri.
Ecco il mio costrutto sulla base di questo rispondere e su questo gist:
#include <tuple>
#include <utility>
template<std::size_t N>
struct tuple_functor
{
template<typename T, typename F>
static void run(std::size_t i, T&& t, F&& f)
{
const std::size_t I = (N - 1);
switch(i)
{
case I:
std::forward<F>(f)(std::get<I>(std::forward<T>(t)));
break;
default:
tuple_functor<I>::run(i, std::forward<T>(t), std::forward<F>(f));
}
}
};
template<>
struct tuple_functor<0>
{
template<typename T, typename F>
static void run(std::size_t, T, F){}
};
È quindi utilizzare come segue:
template<typename... T>
void logger(std::string format, T... args) //behaves like C#'s String.Format()
{
auto tp = std::forward_as_tuple(args...);
auto fc = [](const auto& t){std::cout << t;};
/* ... */
std::size_t some_index = ...
tuple_functor<sizeof...(T)>::run(some_index, tp, fc);
/* ... */
}
Ci potrebbe essere spazio per i miglioramenti.
Come per il codice di OP, sarebbe diventato questo:
const std::size_t num = sizeof...(T);
auto my_tuple = std::forward_as_tuple(t...);
auto do_sth = [](const auto& elem){/* ... */};
for(int i = 0; i < num; ++i)
tuple_functor<num>::run(i, my_tuple, do_sth);
In MSVC STL c'è una funzione _For_each_tuple_element (non documentato):
#include <tuple>
// ...
std::tuple<int, char, float> values{};
std::_For_each_tuple_element(values, [](auto&& value)
{
// process 'value'
});
Di tutte le risposte che ho visto qui, qui e qui , mi piaceva < a href = "https://stackoverflow.com/a/6401663/4618482"> @sigidagi s ' modo di iterazione migliore. Purtroppo, la sua risposta è molto verboso che a mio parere oscura la chiarezza intrinseca.
Questa è la mia versione della sua soluzione che è più conciso e funziona con std::tuple, std::pair e std::array.
template<typename UnaryFunction>
void invoke_with_arg(UnaryFunction)
{}
/**
* Invoke the unary function with each of the arguments in turn.
*/
template<typename UnaryFunction, typename Arg0, typename... Args>
void invoke_with_arg(UnaryFunction f, Arg0&& a0, Args&&... as)
{
f(std::forward<Arg0>(a0));
invoke_with_arg(std::move(f), std::forward<Args>(as)...);
}
template<typename Tuple, typename UnaryFunction, std::size_t... Indices>
void for_each_helper(Tuple&& t, UnaryFunction f, std::index_sequence<Indices...>)
{
using std::get;
invoke_with_arg(std::move(f), get<Indices>(std::forward<Tuple>(t))...);
}
/**
* Invoke the unary function for each of the elements of the tuple.
*/
template<typename Tuple, typename UnaryFunction>
void for_each(Tuple&& t, UnaryFunction f)
{
using size = std::tuple_size<typename std::remove_reference<Tuple>::type>;
for_each_helper(
std::forward<Tuple>(t),
std::move(f),
std::make_index_sequence<size::value>()
);
}
Demo: coliru
std::make_index_sequence C ++ 14 di può essere implementato per C ++ 11 .
constexpr e if constexpr (C ++ 17) questo è abbastanza semplice e diretto:
template <std::size_t I = 0, typename ... Ts>
void print(std::tuple<Ts...> tup) {
if constexpr (I == sizeof...(Ts)) {
return;
} else {
std::cout << std::get<I>(tup) << ' ';
print<I+1>(tup);
}
}
Ho inciampato sullo stesso problema per l'iterazione di una tupla di oggetti funzione, ecco una soluzione in più:
#include <tuple>
#include <iostream>
// Function objects
class A
{
public:
inline void operator()() const { std::cout << "A\n"; };
};
class B
{
public:
inline void operator()() const { std::cout << "B\n"; };
};
class C
{
public:
inline void operator()() const { std::cout << "C\n"; };
};
class D
{
public:
inline void operator()() const { std::cout << "D\n"; };
};
// Call iterator using recursion.
template<typename Fobjects, int N = 0>
struct call_functors
{
static void apply(Fobjects const& funcs)
{
std::get<N>(funcs)();
// Choose either the stopper or descend further,
// depending if N + 1 < size of the tuple.
using caller = std::conditional_t
<
N + 1 < std::tuple_size_v<Fobjects>,
call_functors<Fobjects, N + 1>,
call_functors<Fobjects, -1>
>;
caller::apply(funcs);
}
};
// Stopper.
template<typename Fobjects>
struct call_functors<Fobjects, -1>
{
static void apply(Fobjects const& funcs)
{
}
};
// Call dispatch function.
template<typename Fobjects>
void call(Fobjects const& funcs)
{
call_functors<Fobjects>::apply(funcs);
};
using namespace std;
int main()
{
using Tuple = tuple<A,B,C,D>;
Tuple functors = {A{}, B{}, C{}, D{}};
call(functors);
return 0;
}
Output:
A
B
C
D
Altri hanno menzionato alcune librerie di terze parti ben progettato che si può rivolgersi. Tuttavia, se si utilizza C ++ senza quelle librerie di terze parti, il seguente codice può aiutare.
namespace detail {
template <class Tuple, std::size_t I, class = void>
struct for_each_in_tuple_helper {
template <class UnaryFunction>
static void apply(Tuple&& tp, UnaryFunction& f) {
f(std::get<I>(std::forward<Tuple>(tp)));
for_each_in_tuple_helper<Tuple, I + 1u>::apply(std::forward<Tuple>(tp), f);
}
};
template <class Tuple, std::size_t I>
struct for_each_in_tuple_helper<Tuple, I, typename std::enable_if<
I == std::tuple_size<typename std::decay<Tuple>::type>::value>::type> {
template <class UnaryFunction>
static void apply(Tuple&&, UnaryFunction&) {}
};
} // namespace detail
template <class Tuple, class UnaryFunction>
UnaryFunction for_each_in_tuple(Tuple&& tp, UnaryFunction f) {
detail::for_each_in_tuple_helper<Tuple, 0u>
::apply(std::forward<Tuple>(tp), f);
return std::move(f);
}
Nota: il codice viene compilato con qualsiasi compilatore C ++ supporing 11, e mantiene la coerenza con la progettazione della libreria standard:
-
La tupla non deve essere
std::tuple, e invece può essere qualsiasi cosa che supportastd::getestd::tuple_size; in particolare, possono essere utilizzatistd::arrayestd::pair; -
La tupla può essere un tipo di riferimento o cv qualificato;
-
E 'un comportamento simile a quello
std::for_each, e restituisce ilUnaryFunctiondi input; -
Per 14 C ++ (o laster versione) utenti,
typename std::enable_if<T>::typeetypename std::decay<T>::typepotrebbe essere sostituita con la loro versione semplificata,std::enable_if_t<T>estd::decay_t<T>; -
Per 17 C ++ (o laster versione) utenti,
std::tuple_size<T>::valuepotrebbe essere sostituita con la sua versione semplificata,std::tuple_size_v<T>. -
Per C ++ 20 (o versione Laster) gli utenti, la funzione
SFINAEpotrebbe essere attuato con l'Concepts.
