blocks|key|335726|text|您需要使用模板元编程，如下所示的Boost.Tuple：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|335727|#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;
}|code-block|syntax|javascript|335728|在C%2B%2B0x中，您可以将print_tuple()编写为可变模板函数。|offset|length|style|CODE|335729|entityMap^0|0|0|C|D|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You need to use template metaprogramming, here shown with Boost.Tuple:

<pre><code>#include &lt;boost/tuple/tuple.hpp&gt;
#include &lt;iostream&gt;

template &lt;typename T_Tuple, size_t size&gt;
struct print_tuple_helper {
 static std::ostream &amp; print( std::ostream &amp; s, const T_Tuple &amp; t ) {
 return print_tuple_helper&lt;T_Tuple,size-1&gt;::print( s, t ) &lt;&lt; boost::get&lt;size-1&gt;( t );
 }
};

template &lt;typename T_Tuple&gt;
struct print_tuple_helper&lt;T_Tuple,0&gt; {
 static std::ostream &amp; print( std::ostream &amp; s, const T_Tuple &amp; ) {
 return s;
 }
};

template &lt;typename T_Tuple&gt;
std::ostream &amp; print_tuple( std::ostream &amp; s, const T_Tuple &amp; t ) {
 return print_tuple_helper&lt;T_Tuple,boost::tuples::length&lt;T_Tuple&gt;::value&gt;::print( s, t );
}

int main() {

 const boost::tuple&lt;int,char,float,char,double&gt; t( 0, ' ', 2.5f, '\n', 3.1416 );
 print_tuple( std::cout, t );

 return 0;
}
</code></pre>

In C++0x, you can write <code>print_tuple()</code> as a variadic template function instead.

blocks|key|3312033|text|Boost.Fusion是一种可能性：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3312034|未经测试的示例：|3312035|struct+DoSomething
{
++++template<typename+T>
++++void+operator()(T&+t)+const
++++{
++++++++t.do_sth();
++++}
};

tuple<....>+t+=+...;
boost::fusion::for_each(t,+DoSomething());|code-block|syntax|javascript|3312036|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/libs/fusion/^0|0|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

<a href="http://www.boost.org/libs/fusion/" rel="noreferrer">Boost.Fusion</a> is a possibility:

Untested example:

<pre><code>struct DoSomething
{
 template&lt;typename T&gt;
 void operator()(T&amp; t) const
 {
 t.do_sth();
 }
};

tuple&lt;....&gt; t = ...;
boost::fusion::for_each(t, DoSomething());
</code></pre>

blocks|key|3312070|text|boost的元组提供了帮助器函数get_head()和get_tail()，因此您的帮助器函数可能如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3312071|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());+}|code-block|syntax|javascript|3312072|如此处http://www.boost.org/doc/libs/1_34_0/libs/tuple/doc/tuple_advanced_interface.html中所述|3312073|对于std::tuple，它应该是类似的。|3312074|实际上，不幸的是，std::tuple似乎没有提供这样的接口，所以前面建议的方法应该可以工作，否则您将需要切换到boost::tuple，它有其他优点(比如已经提供的io操作符)。虽然与gcc的boost::tuple有缺点-它还不接受可变模板，但这可能已经被修复，因为我没有在我的机器上安装最新版本的boost。|3312075|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_34_0/libs/tuple/doc/tuple_advanced_interface.html^0|G|A|R|A|0|0|3|29|0|0|2|A|0|9|A|1K|C|2P|C|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|D|@$9|15|A|16|1|17]]|E|$]]|$1|M|3|N|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

boost's tuple provides helper functions <code>get_head()</code> and <code>get_tail()</code> so your helper functions may look like this:

<pre><code>inline void call_do_sth(const null_type&amp;) {};

template &lt;class H, class T&gt;
inline void call_do_sth(cons&lt;H, T&gt;&amp; x) { x.get_head().do_sth(); call_do_sth(x.get_tail()); }
</code></pre>

as described in here <a href="http://www.boost.org/doc/libs/1_34_0/libs/tuple/doc/tuple_advanced_interface.html" rel="nofollow noreferrer">http://www.boost.org/doc/libs/1_34_0/libs/tuple/doc/tuple_advanced_interface.html</a>

with <code>std::tuple</code> it should be similar.

Actually, unfortunately <code>std::tuple</code> does not seem to provide such interface, so methods suggested before should work, or you would need to switch to <code>boost::tuple</code> which has other benefits (like io operators already provided). Though there is downside of <code>boost::tuple</code> with gcc - it does not accept variadic templates yet, but that may be already fixed as I do not have latest version of boost installed on my machine.

blocks|key|333176|text|如果你想使用std::tuple，并且你有支持可变模板的C%2B%2B编译器，试试下面的代码(用g%2B%2B4.5测试过的)。这应该是你问题的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|333177|#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+%2B+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)+);
}|code-block|syntax|javascript|333178|fusion是另一种选择，但它需要自己的元组类型:+boost::fusion::tuple。让我们更好地坚持标准！下面是一个测试：|333179|#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;
}|333180|可变模板的力量！|333181|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you want to use std::tuple and you have C++ compiler which supports variadic templates, try code bellow (tested with g++4.5). This should be the answer to your question.

<pre><code>#include &lt;tuple&gt;

// ------------- UTILITY---------------
template&lt;int...&gt; struct index_tuple{}; 

template&lt;int I, typename IndexTuple, typename... Types&gt; 
struct make_indexes_impl; 

template&lt;int I, int... Indexes, typename T, typename ... Types&gt; 
struct make_indexes_impl&lt;I, index_tuple&lt;Indexes...&gt;, T, Types...&gt; 
{ 
 typedef typename make_indexes_impl&lt;I + 1, index_tuple&lt;Indexes..., I&gt;, Types...&gt;::type type; 
}; 

template&lt;int I, int... Indexes&gt; 
struct make_indexes_impl&lt;I, index_tuple&lt;Indexes...&gt; &gt; 
{ 
 typedef index_tuple&lt;Indexes...&gt; type; 
}; 

template&lt;typename ... Types&gt; 
struct make_indexes : make_indexes_impl&lt;0, index_tuple&lt;&gt;, Types...&gt; 
{}; 

// ----------- FOR EACH -----------------
template&lt;typename Func, typename Last&gt;
void for_each_impl(Func&amp;&amp; f, Last&amp;&amp; last)
{
 f(last);
}

template&lt;typename Func, typename First, typename ... Rest&gt;
void for_each_impl(Func&amp;&amp; f, First&amp;&amp; first, Rest&amp;&amp;...rest) 
{
 f(first);
 for_each_impl( std::forward&lt;Func&gt;(f), rest...);
}

template&lt;typename Func, int ... Indexes, typename ... Args&gt;
void for_each_helper( Func&amp;&amp; f, index_tuple&lt;Indexes...&gt;, std::tuple&lt;Args...&gt;&amp;&amp; tup)
{
 for_each_impl( std::forward&lt;Func&gt;(f), std::forward&lt;Args&gt;(std::get&lt;Indexes&gt;(tup))...);
}

template&lt;typename Func, typename ... Args&gt;
void for_each( std::tuple&lt;Args...&gt;&amp; tup, Func&amp;&amp; f)
{
 for_each_helper(std::forward&lt;Func&gt;(f), 
 typename make_indexes&lt;Args...&gt;::type(), 
 std::forward&lt;std::tuple&lt;Args...&gt;&gt;(tup) );
}

template&lt;typename Func, typename ... Args&gt;
void for_each( std::tuple&lt;Args...&gt;&amp;&amp; tup, Func&amp;&amp; f)
{
 for_each_helper(std::forward&lt;Func&gt;(f), 
 typename make_indexes&lt;Args...&gt;::type(), 
 std::forward&lt;std::tuple&lt;Args...&gt;&gt;(tup) );
}
</code></pre>

boost::fusion is another option, but it requires its own tuple type: boost::fusion::tuple. Lets better stick to the standard! Here is a test:

<pre><code>#include &lt;iostream&gt;

// ---------- FUNCTOR ----------
struct Functor 
{
 template&lt;typename T&gt;
 void operator()(T&amp; t) const { std::cout &lt;&lt; t &lt;&lt; std::endl; }
};

int main()
{
 for_each( std::make_tuple(2, 0.6, 'c'), Functor() );
 return 0;
}
</code></pre>

the power of variadic templates!

blocks|key|333202|text|我有一个基于Iterating+over+a+Tuple的答案|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|333203|#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(t)+<<+std::endl;
++++print<I+%2B+1,+Tp...>(t);
++}

int
main()
{
++typedef+std::tuple<int,+float,+double>+T;
++T+t+=+std::make_tuple(2,+3.14159F,+2345.678);

++print(t);
}|code-block|syntax|javascript|333204|通常的想法是使用编译时递归。事实上，这个想法被用来制作一个类型安全的printf，正如原始元组论文中所指出的那样。|333205|这可以很容易地概括为元组的for_each：|style|CODE|333206|#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(t));
++++for_each<I+%2B+1,+FuncT,+Tp...>(t,+f);
++}|333207|尽管这需要一些努力才能让FuncT为元组可能包含的每种类型提供适当的重载。如果您知道所有元组元素都将共享一个公共基类或类似的类，则此方法效果最好。|333208|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/4832949/c-iterating-over-a-tuple-resolution-of-type-vs-constant-parameters^0|6|M|0|0|0|0|D|8|0|0|C|5|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|16|8|@$A|17|B|18|M|N]]|9|@]|C|$]]|$1|O|3|P|5|F|7|19|8|@]|9|@]|C|$G|H]]|$1|Q|3|R|5|6|7|1A|8|@$A|1B|B|1C|M|N]]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

I have an answer based on <a href="https://stackoverflow.com/questions/4832949/c-iterating-over-a-tuple-resolution-of-type-vs-constant-parameters">Iterating over a Tuple</a>:

<pre><code>#include &lt;tuple&gt;
#include &lt;utility&gt; 
#include &lt;iostream&gt;

template&lt;std::size_t I = 0, typename... Tp&gt;
inline typename std::enable_if&lt;I == sizeof...(Tp), void&gt;::type
 print(std::tuple&lt;Tp...&gt;&amp; t)
 { }

template&lt;std::size_t I = 0, typename... Tp&gt;
inline typename std::enable_if&lt;I &lt; sizeof...(Tp), void&gt;::type
 print(std::tuple&lt;Tp...&gt;&amp; t)
 {
 std::cout &lt;&lt; std::get&lt;I&gt;(t) &lt;&lt; std::endl;
 print&lt;I + 1, Tp...&gt;(t);
 }

int
main()
{
 typedef std::tuple&lt;int, float, double&gt; T;
 T t = std::make_tuple(2, 3.14159F, 2345.678);

 print(t);
}
</code></pre>

The usual idea is to use compile time recursion. In fact, this idea is used to make a printf that is type safe as noted in the original tuple papers.

This can be easily generalized into a <code>for_each</code> for tuples:

<pre><code>#include &lt;tuple&gt;
#include &lt;utility&gt; 

template&lt;std::size_t I = 0, typename FuncT, typename... Tp&gt;
inline typename std::enable_if&lt;I == sizeof...(Tp), void&gt;::type
 for_each(std::tuple&lt;Tp...&gt; &amp;, FuncT) // Unused arguments are given no names.
 { }

template&lt;std::size_t I = 0, typename FuncT, typename... Tp&gt;
inline typename std::enable_if&lt;I &lt; sizeof...(Tp), void&gt;::type
 for_each(std::tuple&lt;Tp...&gt;&amp; t, FuncT f)
 {
 f(std::get&lt;I&gt;(t));
 for_each&lt;I + 1, FuncT, Tp...&gt;(t, f);
 }
</code></pre>

Though this then requires some effort to have <code>FuncT</code> represent something with the appropriate overloads for every type the tuple might contain. This works best if you know all the tuple elements will share a common base class or something similar.

blocks|key|334752|text|使用Boost.Hana和泛型lambda：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|334753|#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;
}|code-block|syntax|javascript|334754|http://coliru.stacked-crooked.com/a/27b3691f55caf271|offset|length|334755|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|1G|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@]|9|@$I|U|J|V|1|W]]|A|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|H]]]]

Use Boost.Hana and generic lambdas:

<pre><code>#include &lt;tuple&gt;
#include &lt;iostream&gt;
#include &lt;boost/hana.hpp&gt;
#include &lt;boost/hana/ext/std/tuple.hpp&gt;

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 &amp;foo) {
 cout &lt;&lt; foo.foo() &lt;&lt; endl;
 });

 cout &lt;&lt; "foo2.bar after mutation: " &lt;&lt; foo2.bar &lt;&lt; endl;
}
</code></pre>

<a href="http://coliru.stacked-crooked.com/a/27b3691f55caf271" rel="noreferrer">http://coliru.stacked-crooked.com/a/27b3691f55caf271</a>

blocks|key|335783|text|首先定义一些索引助手：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|335784|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...>+{};|code-block|syntax|javascript|335785|使用您的函数，您希望应用于每个元组元素：|335786|template+<typename+T>
/*+...+*/+foo(T+t)+{+/*+...+*/+}|335787|你可以这样写：|335788|template<typename+...T,+size_t+...I>
/*+...+*/+do_foo_helper(std::tuple<T...>+&ts,+index_sequence<I...>)+{
++++std::tie(foo(std::get(ts))+...);
}

template+<typename+...T>
/*+...+*/+do_foo(std::tuple<T...>+&ts)+{
++++return+do_foo_helper(ts,+make_index_sequence<sizeof...(T)>());
}|335789|或者，如果foo返回void，则使用|offset|length|style|CODE|335790|std::tie((foo(std::get(ts)),+1)+...+);|335791|注意:在C%2B%2B14上，已经定义了make_index_sequence+(http://en.cppreference.com/w/cpp/utility/integer_sequence)。|335792|如果您确实需要一个从左到右的求值顺序，请考虑如下所示：|335793|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(ts)+...);
}

template+<typename+...T>
void+do_foo(std::tuple<T...>+&ts)+{
++++do_foo_helper(ts,+make_index_sequence<sizeof...(T)>());
}|335794|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/utility/integer_sequence^0|0|0|0|0|0|0|5|3|A|4|0|0|G|J|11|1L|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1C|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1E|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1G|8|@$Q|1H|R|1I|S|T]|$Q|1J|R|1K|S|T]]|9|@]|A|$]]|$1|U|3|V|5|D|7|1L|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1M|8|@$Q|1N|R|1O|S|T]]|9|@$Q|1P|R|1Q|1|1R]]|A|$]]|$1|Y|3|Z|5|6|7|1S|8|@]|9|@]|A|$]]|$1|10|3|11|5|D|7|1T|8|@]|9|@]|A|$E|F]]|$1|12|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]]|13|$14|$5|15|16|17|A|$18|19]]]]

First define some index helpers:

<pre><code>template &lt;size_t ...I&gt;
struct index_sequence {};

template &lt;size_t N, size_t ...I&gt;
struct make_index_sequence : public make_index_sequence&lt;N - 1, N - 1, I...&gt; {};

template &lt;size_t ...I&gt;
struct make_index_sequence&lt;0, I...&gt; : public index_sequence&lt;I...&gt; {};
</code></pre>

With your function you would like to apply on each tuple element:

<pre><code>template &lt;typename T&gt;
/* ... */ foo(T t) { /* ... */ }
</code></pre>

you can write:

<pre><code>template&lt;typename ...T, size_t ...I&gt;
/* ... */ do_foo_helper(std::tuple&lt;T...&gt; &amp;ts, index_sequence&lt;I...&gt;) {
 std::tie(foo(std::get&lt;I&gt;(ts)) ...);
}

template &lt;typename ...T&gt;
/* ... */ do_foo(std::tuple&lt;T...&gt; &amp;ts) {
 return do_foo_helper(ts, make_index_sequence&lt;sizeof...(T)&gt;());
}
</code></pre>

Or if <code>foo</code> returns <code>void</code>, use

<pre><code>std::tie((foo(std::get&lt;I&gt;(ts)), 1) ... );
</code></pre>

Note: On C++14 <code>make_index_sequence</code> is already defined (<a href="http://en.cppreference.com/w/cpp/utility/integer_sequence" rel="noreferrer">http://en.cppreference.com/w/cpp/utility/integer_sequence</a>).

If you do need a left-to-right evaluation order, consider something like this:

<pre><code>template &lt;typename T, typename ...R&gt;
void do_foo_iter(T t, R ...r) {
 foo(t);
 do_foo(r...);
}

void do_foo_iter() {}

template&lt;typename ...T, size_t ...I&gt;
void do_foo_helper(std::tuple&lt;T...&gt; &amp;ts, index_sequence&lt;I...&gt;) {
 do_foo_iter(std::get&lt;I&gt;(ts) ...);
}

template &lt;typename ...T&gt;
void do_foo(std::tuple&lt;T...&gt; &amp;ts) {
 do_foo_helper(ts, make_index_sequence&lt;sizeof...(T)&gt;());
}
</code></pre>

blocks|key|334781|text|我可能错过了这列火车，但这将是未来的参考。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|334782|下面是我基于这个answer和这个gist的构造|offset|length|334783|#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(std::forward<T>(t)));
++++++++++++break;

++++++++default:
++++++++++++tuple_functor::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){}
};|code-block|syntax|javascript|334784|然后按如下方式使用它：|334785|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);

++++/*+...+*/
}|334786|可能还有改进的空间。|334787|334788|根据OP的代码，它将变成这样：|334789|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;+%2B%2Bi)
++++tuple_functor<num>::run(i,+my_tuple,+do_sth);|334790|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/28998020/2748628|1|https://gist.github.com/elbeno/969b0f1765ae23554bbe^0|0|8|6|0|H|4|1|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@]|9|@$D|17|E|18|1|19]|$D|1A|E|1B|1|1C]]|A|$]]|$1|F|3|G|5|H|7|1D|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1E|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|1F|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1I|8|@]|9|@]|A|$]]|$1|T|3|U|5|H|7|1J|8|@]|9|@]|A|$I|J]]|$1|V|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|12]]|13|$5|Y|Z|10|A|$11|14]]]]

I might have missed this train, but this will be here for future reference. 
Here's my construct based on this <a href="https://stackoverflow.com/a/28998020/2748628">answer</a> and on this <a href="https://gist.github.com/elbeno/969b0f1765ae23554bbe" rel="nofollow noreferrer">gist</a>:

<pre class="lang-cpp prettyprint-override"><code>#include &lt;tuple&gt;
#include &lt;utility&gt;

template&lt;std::size_t N&gt;
struct tuple_functor
{
 template&lt;typename T, typename F&gt;
 static void run(std::size_t i, T&amp;&amp; t, F&amp;&amp; f)
 {
 const std::size_t I = (N - 1);
 switch(i)
 {
 case I:
 std::forward&lt;F&gt;(f)(std::get&lt;I&gt;(std::forward&lt;T&gt;(t)));
 break;

 default:
 tuple_functor&lt;I&gt;::run(i, std::forward&lt;T&gt;(t), std::forward&lt;F&gt;(f));
 }
 }
};

template&lt;&gt;
struct tuple_functor&lt;0&gt;
{
 template&lt;typename T, typename F&gt;
 static void run(std::size_t, T, F){}
};
</code></pre>

You then use it as follow:

<pre class="lang-cpp prettyprint-override"><code>template&lt;typename... T&gt;
void logger(std::string format, T... args) //behaves like C#'s String.Format()
{
 auto tp = std::forward_as_tuple(args...);
 auto fc = [](const auto&amp; t){std::cout &lt;&lt; t;};

 /* ... */

 std::size_t some_index = ...
 tuple_functor&lt;sizeof...(T)&gt;::run(some_index, tp, fc);

 /* ... */
}
</code></pre>

There could be room for improvements.

<hr>

As per OP's code, it would become this:

<pre class="lang-cpp prettyprint-override"><code>const std::size_t num = sizeof...(T);
auto my_tuple = std::forward_as_tuple(t...);
auto do_sth = [](const auto&amp; elem){/* ... */};
for(int i = 0; i &lt; num; ++i)
 tuple_functor&lt;num&gt;::run(i, my_tuple, do_sth);
</code></pre>

blocks|key|3312204|text|在C%2B%2B17中，您可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3312205|std::apply([](auto+...x){std::make_tuple(x.do_something()...);}+,+the_tuple);|code-block|syntax|javascript|3312206|这已经在Clang%2B%2B+3.9中起作用了，使用std：：实验性：：apply。|3312207|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In C++17 you can do this:

<pre><code>std::apply([](auto ...x){std::make_tuple(x.do_something()...);} , the_tuple);
</code></pre>

This already works in Clang++ 3.9, using std::experimental::apply.

blocks|key|338105|text|这里有一个简单的C%2B%2B17方法，可以使用标准库遍历元组项目：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|338106|#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+%2B+1+<+Size)
++++++++++++for_each<Index+%2B+1>(
++++++++++++++++std::forward<TTuple>(tuple),
++++++++++++++++std::forward<TCallable>(callable),
++++++++++++++++std::forward<TArgs>(args)...);
++++}
}|code-block|syntax|javascript|338107|示例：|338108|#include+<iostream>

int+main()
{
++++std::tuple<int,+char>+items{1,+'a'};
++++for_each(items,+[](const+auto&+item)+{
++++++++std::cout+<<+item+<<+"\n";
++++});
}|338109|输出：|338110|1
a|338111|这可以扩展到有条件地中断循环，以防callable返回值(但仍然可以使用不返回布尔赋值的可调用对象，例如void)：|338112|#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+%2B+1+<+Size)
++++++++++++for_each<Index+%2B+1>(
++++++++++++++++std::forward<TTuple>(tuple),
++++++++++++++++std::forward<TCallable>(callable),
++++++++++++++++std::forward<TArgs>(args)...);
++++}
}|338113|338114|#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;
++++});
}|338115|338116|1
a
---
1|338117|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|S|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|T|3|U|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|V|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|Y|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|Z|$]]

Here's an easy C++17 way of iterating over tuple items with just standard library:

<pre><code>#include &lt;tuple&gt; // std::tuple
#include &lt;functional&gt; // std::invoke

template &lt;
 size_t Index = 0, // start iteration at 0 index
 typename TTuple, // the tuple type
 size_t Size =
 std::tuple_size_v&lt;
 std::remove_reference_t&lt;TTuple&gt;&gt;, // tuple size
 typename TCallable, // the callable to bo invoked for each tuple item
 typename... TArgs // other arguments to be passed to the callable 
&gt;
void for_each(TTuple&amp;&amp; tuple, TCallable&amp;&amp; callable, TArgs&amp;&amp;... args)
{
 if constexpr (Index &lt; Size)
 {
 std::invoke(callable, args..., std::get&lt;Index&gt;(tuple));

 if constexpr (Index + 1 &lt; Size)
 for_each&lt;Index + 1&gt;(
 std::forward&lt;TTuple&gt;(tuple),
 std::forward&lt;TCallable&gt;(callable),
 std::forward&lt;TArgs&gt;(args)...);
 }
}
</code></pre>

Example:

<pre><code>#include &lt;iostream&gt;

int main()
{
 std::tuple&lt;int, char&gt; items{1, 'a'};
 for_each(items, [](const auto&amp; item) {
 std::cout &lt;&lt; item &lt;&lt; "\n";
 });
}
</code></pre>

Output:

<pre><code>1
a
</code></pre>

This can be extended to conditionally break the loop in case the callable returns a value (but still work with callables that do not return a bool assignable value, e.g. void):

<pre><code>#include &lt;tuple&gt; // std::tuple
#include &lt;functional&gt; // std::invoke

template &lt;
 size_t Index = 0, // start iteration at 0 index
 typename TTuple, // the tuple type
 size_t Size =
 std::tuple_size_v&lt;
 std::remove_reference_t&lt;TTuple&gt;&gt;, // tuple size
 typename TCallable, // the callable to bo invoked for each tuple item
 typename... TArgs // other arguments to be passed to the callable 
 &gt;
 void for_each(TTuple&amp;&amp; tuple, TCallable&amp;&amp; callable, TArgs&amp;&amp;... args)
{
 if constexpr (Index &lt; Size)
 {
 if constexpr (std::is_assignable_v&lt;bool&amp;, std::invoke_result_t&lt;TCallable&amp;&amp;, TArgs&amp;&amp;..., decltype(std::get&lt;Index&gt;(tuple))&gt;&gt;)
 {
 if (!std::invoke(callable, args..., std::get&lt;Index&gt;(tuple)))
 return;
 }
 else
 {
 std::invoke(callable, args..., std::get&lt;Index&gt;(tuple));
 }

 if constexpr (Index + 1 &lt; Size)
 for_each&lt;Index + 1&gt;(
 std::forward&lt;TTuple&gt;(tuple),
 std::forward&lt;TCallable&gt;(callable),
 std::forward&lt;TArgs&gt;(args)...);
 }
}
</code></pre>

Example:

<pre><code>#include &lt;iostream&gt;

int main()
{
 std::tuple&lt;int, char&gt; items{ 1, 'a' };
 for_each(items, [](const auto&amp; item) {
 std::cout &lt;&lt; item &lt;&lt; "\n";
 });

 std::cout &lt;&lt; "---\n";

 for_each(items, [](const auto&amp; item) {
 std::cout &lt;&lt; item &lt;&lt; "\n";
 return false;
 });
}
</code></pre>

Output:

<pre><code>1
a
---
1
</code></pre>

blocks|key|338146|text|在MSVC+STL中有一个_For_each_tuple_element函数(没有文档)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|338147|#include+<tuple>

//+...

std::tuple<int,+char,+float>+values{};
std::_For_each_tuple_element(values,+[](auto&&+value)
{
++++//+process+'value'
});|code-block|syntax|javascript|338148|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In MSVC STL there's a _For_each_tuple_element function (not documented):

<pre><code>#include &lt;tuple&gt;

// ...

std::tuple&lt;int, char, float&gt; values{};
std::_For_each_tuple_element(values, [](auto&amp;&amp; value)
{
 // process 'value'
});
</code></pre>

blocks|key|3099504|text|在我在这里看到的所有答案中，here和here，我最喜欢@sigidagi的迭代方式。不幸的是，他的答案非常冗长，在我看来，这掩盖了内在的清晰度。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3099505|这是我对他的解决方案的版本，它更简洁，可以与std::tuple，std::pair和std::array一起使用。|style|CODE|3099506|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>()
++++);
}|code-block|syntax|javascript|3099507|演示：coliru|3099508|C%2B%2B14的std::make_index_sequence可以在for+C%2B%2B11上实现。|3099509|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/26902633/how-to-iterate-over-a-stdtuple-in-c-11|1|https://stackoverflow.com/questions/16387354/template-tuple-calling-a-function-on-each-element#16387374|2|https://stackoverflow.com/a/6401663/4618482|3|http://coliru.stacked-crooked.com/a/2dbe998b1b1d4b49|4|https://stackoverflow.com/a/50000638/4618482^0|E|4|0|J|4|1|S|9|2|0|M|A|X|9|17|A|0|0|3|6|3|0|6|O|X|9|4|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]|$A|1A|B|1B|1|1C]|$A|1D|B|1E|1|1F]]|C|$]]|$1|D|3|E|5|6|7|1G|8|@$A|1H|B|1I|F|G]|$A|1J|B|1K|F|G]|$A|1L|B|1M|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|1N|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1O|8|@]|9|@$A|1P|B|1Q|1|1R]]|C|$]]|$1|O|3|P|5|6|7|1S|8|@$A|1T|B|1U|F|G]]|9|@$A|1V|B|1W|1|1X]]|C|$]]|$1|Q|3|-4|5|6|7|1Y|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]|Y|$5|T|U|V|C|$W|Z]]|10|$5|T|U|V|C|$W|11]]|12|$5|T|U|V|C|$W|13]]|14|$5|T|U|V|C|$W|15]]]]

Of all the answers I've seen here, <a href="https://stackoverflow.com/questions/26902633/how-to-iterate-over-a-stdtuple-in-c-11">here</a> and <a href="https://stackoverflow.com/questions/16387354/template-tuple-calling-a-function-on-each-element#16387374">here</a>, I liked <a href="https://stackoverflow.com/a/6401663/4618482">@sigidagi</a>'s way of iterating best. Unfortunately, his answer is very verbose which in my opinion obscures the inherent clarity.

This is my version of his solution which is more concise and works with <code>std::tuple</code>, <code>std::pair</code> and <code>std::array</code>.

<pre><code>template&lt;typename UnaryFunction&gt;
void invoke_with_arg(UnaryFunction)
{}

/**
 * Invoke the unary function with each of the arguments in turn.
 */
template&lt;typename UnaryFunction, typename Arg0, typename... Args&gt;
void invoke_with_arg(UnaryFunction f, Arg0&amp;&amp; a0, Args&amp;&amp;... as)
{
 f(std::forward&lt;Arg0&gt;(a0));
 invoke_with_arg(std::move(f), std::forward&lt;Args&gt;(as)...);
}

template&lt;typename Tuple, typename UnaryFunction, std::size_t... Indices&gt;
void for_each_helper(Tuple&amp;&amp; t, UnaryFunction f, std::index_sequence&lt;Indices...&gt;)
{
 using std::get;
 invoke_with_arg(std::move(f), get&lt;Indices&gt;(std::forward&lt;Tuple&gt;(t))...);
}

/**
 * Invoke the unary function for each of the elements of the tuple.
 */
template&lt;typename Tuple, typename UnaryFunction&gt;
void for_each(Tuple&amp;&amp; t, UnaryFunction f)
{
 using size = std::tuple_size&lt;typename std::remove_reference&lt;Tuple&gt;::type&gt;;
 for_each_helper(
 std::forward&lt;Tuple&gt;(t),
 std::move(f),
 std::make_index_sequence&lt;size::value&gt;()
 );
}
</code></pre>

Demo: <a href="http://coliru.stacked-crooked.com/a/2dbe998b1b1d4b49" rel="nofollow noreferrer">coliru</a>

C++14's <code>std::make_index_sequence</code> can be implemented <a href="https://stackoverflow.com/a/50000638/4618482">for C++11</a>.

blocks|key|3099564|text|我在迭代function对象的元组时遇到了同样的问题，所以这里是另一个解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3099565|#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+%2B+1+<+size+of+the+tuple.+
++++++++using+caller+=+std::conditional_t
++++++++<
++++++++++++N+%2B+1+<+std::tuple_size_v<Fobjects>,
++++++++++++call_functors<Fobjects,+N+%2B+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;+
}|code-block|syntax|javascript|3099566|输出：|3099567|A+
B+
C+
D|3099568|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I have stumbled on the same problem for iterating over a tuple of function objects, so here is one more solution:

<pre><code>#include &lt;tuple&gt; 
#include &lt;iostream&gt;

// Function objects
class A 
{
 public: 
 inline void operator()() const { std::cout &lt;&lt; "A\n"; };
};

class B 
{
 public: 
 inline void operator()() const { std::cout &lt;&lt; "B\n"; };
};

class C 
{
 public:
 inline void operator()() const { std::cout &lt;&lt; "C\n"; };
};

class D 
{
 public:
 inline void operator()() const { std::cout &lt;&lt; "D\n"; };
};


// Call iterator using recursion.
template&lt;typename Fobjects, int N = 0&gt; 
struct call_functors 
{
 static void apply(Fobjects const&amp; funcs)
 {
 std::get&lt;N&gt;(funcs)(); 

 // Choose either the stopper or descend further, 
 // depending if N + 1 &lt; size of the tuple. 
 using caller = std::conditional_t
 &lt;
 N + 1 &lt; std::tuple_size_v&lt;Fobjects&gt;,
 call_functors&lt;Fobjects, N + 1&gt;, 
 call_functors&lt;Fobjects, -1&gt;
 &gt;;

 caller::apply(funcs); 
 }
};

// Stopper.
template&lt;typename Fobjects&gt; 
struct call_functors&lt;Fobjects, -1&gt;
{
 static void apply(Fobjects const&amp; funcs)
 {
 }
};

// Call dispatch function.
template&lt;typename Fobjects&gt;
void call(Fobjects const&amp; funcs)
{
 call_functors&lt;Fobjects&gt;::apply(funcs);
};


using namespace std; 

int main()
{
 using Tuple = tuple&lt;A,B,C,D&gt;; 

 Tuple functors = {A{}, B{}, C{}, D{}}; 

 call(functors); 

 return 0; 
}
</code></pre>

Output: 

<pre><code>A 
B 
C 
D
</code></pre>

blocks|key|335947|text|其他人提到了一些设计良好的第三方库，您可能会求助于它们。但是，如果您使用的是没有这些第三方库的C%2B%2B，下面的代码可能会有所帮助。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|335948|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(std::forward<Tuple>(tp)));
++++for_each_in_tuple_helper<Tuple,+I+%2B+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);
}|code-block|syntax|javascript|335949|注意:代码可以在任何支持C%2B%2B11的编译器上编译，并且与标准库的设计保持一致：|335950|335951|元组不需要是std::tuple，而是可以是支持std::get和std::tuple_size的任何内容；特别是可以使用std::array和std::pair；|ordered-list-item|offset|length|style|CODE|335952|元组可以是引用类型，或者std::array的行为与D12相似，并返回输入的UnaryFunction;|335953|For代码(或激光版本)用户，D16和D17可以用它们的简化版本替换，D18和D19可以用它们的简化版本替换；对于|335954|+C%2B%2B17+(或激光版本)用户，可以用其简化版本替换std::tuple_size<T>::value，std::tuple_size_v<T>.|335955|For+SFINAE+(或激光版本)用户可以使用Concepts.|335956|实现std::tuple_size<T>::value功能|335957|entityMap^0|0|0|0|0|6|A|O|8|X|F|1P|A|20|9|0|C|A|12|D|0|0|R|P|1H|K|0|4|6|O|8|0|2|P|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|16|8|@$M|17|N|18|O|P]|$M|19|N|1A|O|P]|$M|1B|N|1C|O|P]|$M|1D|N|1E|O|P]|$M|1F|N|1G|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1H|8|@$M|1I|N|1J|O|P]|$M|1K|N|1L|O|P]]|9|@]|A|$]]|$1|S|3|T|5|L|7|1M|8|@]|9|@]|A|$]]|$1|U|3|V|5|L|7|1N|8|@$M|1O|N|1P|O|P]|$M|1Q|N|1R|O|P]]|9|@]|A|$]]|$1|W|3|X|5|L|7|1S|8|@$M|1T|N|1U|O|P]|$M|1V|N|1W|O|P]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1X|8|@$M|1Y|N|1Z|O|P]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|20|8|@]|9|@]|A|$]]]|11|$]]

Others have mentioned some well-designed third-party libraries that you may turn to. However, if you are using C++ without those third-party libraries, the following code may help.

<pre><code>namespace detail {

template &lt;class Tuple, std::size_t I, class = void&gt;
struct for_each_in_tuple_helper {
 template &lt;class UnaryFunction&gt;
 static void apply(Tuple&amp;&amp; tp, UnaryFunction&amp; f) {
 f(std::get&lt;I&gt;(std::forward&lt;Tuple&gt;(tp)));
 for_each_in_tuple_helper&lt;Tuple, I + 1u&gt;::apply(std::forward&lt;Tuple&gt;(tp), f);
 }
};

template &lt;class Tuple, std::size_t I&gt;
struct for_each_in_tuple_helper&lt;Tuple, I, typename std::enable_if&lt;
 I == std::tuple_size&lt;typename std::decay&lt;Tuple&gt;::type&gt;::value&gt;::type&gt; {
 template &lt;class UnaryFunction&gt;
 static void apply(Tuple&amp;&amp;, UnaryFunction&amp;) {}
};

} // namespace detail

template &lt;class Tuple, class UnaryFunction&gt;
UnaryFunction for_each_in_tuple(Tuple&amp;&amp; tp, UnaryFunction f) {
 detail::for_each_in_tuple_helper&lt;Tuple, 0u&gt;
 ::apply(std::forward&lt;Tuple&gt;(tp), f);
 return std::move(f);
}
</code></pre>

Note: The code compiles with any compiler supporing C++11, and it keeps consistency with design of the standard library:

<ol>
<li>The tuple need not be <code>std::tuple</code>, and instead may be anything that supports <code>std::get</code> and <code>std::tuple_size</code>; in particular, <code>std::array</code> and <code>std::pair</code> may be used;</li>
<li>The tuple may be a reference type or cv-qualified;</li>
<li>It has similar behavior as <code>std::for_each</code>, and returns the input <code>UnaryFunction</code>;</li>
<li>For C++14 (or laster version) users, <code>typename std::enable_if&lt;T&gt;::type</code> and <code>typename std::decay&lt;T&gt;::type</code> could be replaced with their simplified version, <code>std::enable_if_t&lt;T&gt;</code> and <code>std::decay_t&lt;T&gt;</code>;</li>
<li>For C++17 (or laster version) users, <code>std::tuple_size&lt;T&gt;::value</code> could be replaced with its simplified version, <code>std::tuple_size_v&lt;T&gt;</code>.</li>
<li>For C++20 (or laster version) users, the <code>SFINAE</code> feature could be implemented with the <code>Concepts</code>.</li>
</ol>

blocks|key|3312572|text|在C%2B%2B17中，您可以将std::apply与fold+expression一起使用|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3312573|std::apply([](auto&&...+args)+{((/*+args.dosomething()+*/),+...);},+the_tuple);|code-block|syntax|javascript|3312574|打印元组的完整示例：|3312575|#include+<tuple>
#include+<iostream>

int+main()
{
++++std::tuple+t{42,+'a',+4.2};+//+Another+C%2B%2B17+feature:+class+template+argument+deduction
++++std::apply([](auto&&...+args)+{((std::cout+<<+args+<<+'\n'),+...);},+t);
}|3312576|[Online+Example+on+Coliru]|3312577|该方案解决了M.+Alaggan's+answer中的求值顺序问题。|3312578|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/utility/apply|1|https://en.cppreference.com/w/cpp/language/fold|2|http://coliru.stacked-crooked.com/a/0f98350719456d66|3|https://stackoverflow.com/a/37100178/5376789^0|C|A|C|A|0|N|F|1|0|0|0|0|0|Q|2|0|6|J|3|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@$9|19|A|1A|1|1B]|$9|1C|A|1D|1|1E]]|E|$]]|$1|F|3|G|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1G|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1I|8|@]|D|@$9|1J|A|1K|1|1L]]|E|$]]|$1|Q|3|R|5|6|7|1M|8|@]|D|@$9|1N|A|1O|1|1P]]|E|$]]|$1|S|3|-4|5|6|7|1Q|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]|12|$5|V|W|X|E|$Y|13]]|14|$5|V|W|X|E|$Y|15]]]]

In C++17, you can use <a href="https://en.cppreference.com/w/cpp/utility/apply" rel="noreferrer"><code>std::apply</code></a> with <a href="https://en.cppreference.com/w/cpp/language/fold" rel="noreferrer">fold expression</a>:

<pre><code>std::apply([](auto&amp;&amp;... args) {((/* args.dosomething() */), ...);}, the_tuple);
</code></pre>

A complete example for printing a tuple:

<pre><code>#include &lt;tuple&gt;
#include &lt;iostream&gt;

int main()
{
 std::tuple t{42, 'a', 4.2}; // Another C++17 feature: class template argument deduction
 std::apply([](auto&amp;&amp;... args) {((std::cout &lt;&lt; args &lt;&lt; '\n'), ...);}, t);
}
</code></pre>

<a href="http://coliru.stacked-crooked.com/a/0f98350719456d66" rel="noreferrer">[Online Example on Coliru]</a>

This solution solves the issue of evaluation order in <a href="https://stackoverflow.com/a/37100178/5376789">M. Alaggan's answer</a>.

blocks|key|3099782|text|在C%2B%2B17中，使用if+constexpr是一种更简单、直观和对编译器友好的方法|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3099783|//+prints+every+element+of+a+tuple
template<size_t+I+=+0,+typename...+Tp>
void+print(std::tuple<Tp...>&+t)+{
++++std::cout+<<+std::get(t)+<<+"+";
++++//+do+things
++++if+constexpr(I%2B1+!=+sizeof...(Tp))
++++++++print<I%2B1>(t);
}|code-block|syntax|javascript|3099784|这是编译时递归，与@emsr提供的类似。但是它没有使用SFINAE，所以(我认为)它对编译器更友好。|3099785|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/language/if^0|A|C|A|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|11|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

A more simple, intuitive and compiler-friendly way of doing this in C++17, using <a href="https://en.cppreference.com/w/cpp/language/if" rel="noreferrer"><code>if constexpr</code></a>:

<pre class="lang-cpp prettyprint-override"><code>// prints every element of a tuple
template&lt;size_t I = 0, typename... Tp&gt;
void print(std::tuple&lt;Tp...&gt;&amp; t) {
 std::cout &lt;&lt; std::get&lt;I&gt;(t) &lt;&lt; " ";
 // do things
 if constexpr(I+1 != sizeof...(Tp))
 print&lt;I+1&gt;(t);
}
</code></pre>

This is compile-time recursion, similar to the one presented by @emsr. But this doesn't use SFINAE so (I think) it is more compiler-friendly.

blocks|key|334968|text|C%2B%2B为此引入了expansion+statements。他们最初在C%2B%2B20的轨道上，但由于缺乏语言措辞审查的时间(见here和here)，险些错过了削减。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|334969|当前达成一致的语法(请参阅上面的链接)是：|334970|{
++++auto+tup+=+std::make_tuple(0,+'a',+3.14);
++++template+for+(auto+elem+:+tup)
++++++++std::cout+<<+elem+<<+std::endl;
}|code-block|syntax|javascript|334971|entityMap|0|LINK|mutability|MUTABLE|url|http://wg21.link/p1306|1|https://www.reddit.com/r/cpp/comments/cfk9de/201907_cologne_iso_c_committee_trip_report_the/|2|https://www.reddit.com/r/cpp/comments/cfk9de/201907_cologne_iso_c_committee_trip_report_the/eub5li9/^0|8|K|0|1O|4|1|1T|4|2|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]|$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]|U|$5|N|O|P|C|$Q|V]]]]

C++ is introducing <a href="http://wg21.link/p1306" rel="noreferrer">expansion statements</a> for this purpose. They were originally on track for C++20 but narrowly missed the cut due to a lack of time for language wording review (see <a href="https://www.reddit.com/r/cpp/comments/cfk9de/201907_cologne_iso_c_committee_trip_report_the/" rel="noreferrer">here</a> and <a href="https://www.reddit.com/r/cpp/comments/cfk9de/201907_cologne_iso_c_committee_trip_report_the/eub5li9/" rel="noreferrer">here</a>).

The currently agreed syntax (see the links above) is:

<pre><code>{
 auto tup = std::make_tuple(0, 'a', 3.14);
 template for (auto elem : tup)
 std::cout &lt;&lt; elem &lt;&lt; std::endl;
}
</code></pre>

blocks|key|3312660|text|使用constexpr和if+constexpr(C%2B%2B17)，这是相当简单和直接的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3312661|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(tup)+<<+'+';
++++print<I%2B1>(tup);
++}
}|code-block|syntax|javascript|3312662|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/language/constexpr|1|https://en.cppreference.com/w/cpp/language/if^0|2|9|C|C|2|9|0|C|C|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]|$9|12|A|13|1|14]]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

Using <a href="https://en.cppreference.com/w/cpp/language/constexpr" rel="nofollow noreferrer"><code>constexpr</code></a> and <a href="https://en.cppreference.com/w/cpp/language/if" rel="nofollow noreferrer"><code>if constexpr</code></a>(C++17) this is fairly simple and straight forward:

<pre><code>template &lt;std::size_t I = 0, typename ... Ts&gt;
void print(std::tuple&lt;Ts...&gt; tup) {
 if constexpr (I == sizeof...(Ts)) {
 return;
 } else {
 std::cout &lt;&lt; std::get&lt;I&gt;(tup) &lt;&lt; ' ';
 print&lt;I+1&gt;(tup);
 }
}
</code></pre>

blocks|key|336048|text|另一种选择是为元组实现迭代器。这样做的好处是，您可以使用标准库和基于范围的for循环提供的各种算法。这里解释了一种优雅的方法，https://foonathan.net/2017/03/tuple-iterator/。其基本思想是使用begin()和end()方法提供迭代器，将元组转换为范围。迭代器本身返回一个std::variant<...>，然后可以使用std::visit访问该The。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|336049|下面是一些例子：|336050|auto+t+=+std::tuple{+1,+2.f,+3.0+};
auto+r+=+to_range(t);

for(auto+v+:+r)
{
++++std::visit(unwrap([](auto&+x)
++++++++{
++++++++++++x+=+1;
++++++++}),+v);
}

std::for_each(begin(r),+end(r),+[](auto+v)
++++{
++++++++std::visit(unwrap([](auto&+x)
++++++++++++{
++++++++++++++++x+=+0;
++++++++++++}),+v);
++++});

std::accumulate(begin(r),+end(r),+0.0,+[](auto+acc,+auto+v)
++++{
++++++++return+acc+%2B+std::visit(unwrap([](auto&+x)
++++++++{
++++++++++++return+static_cast<double>(x);
++++++++}),+v);
++++});

std::for_each(begin(r),+end(r),+[](auto+v)
{
++++std::visit(unwrap([](const+auto&+x)
++++++++{
++++++++++++std::cout+<<+x+<<+std::endl;
++++++++}),+v);
});

std::for_each(begin(r),+end(r),+[](auto+v)
{
++++std::visit(overload(
++++++++[](int+x)+{+std::cout+<<+"int"+<<+std::endl;+},
++++++++[](float+x)+{+std::cout+<<+"float"+<<+std::endl;+},
++++++++[](double+x)+{+std::cout+<<+"double"+<<+std::endl;+}),+v);
});|code-block|syntax|javascript|336051|我的实现(很大程度上基于上面链接中的解释)：|336052|#ifndef+TUPLE_RANGE_H
#define+TUPLE_RANGE_H

#include+<utility>
#include+<functional>
#include+<variant>
#include+<type_traits>

template<typename+Accessor>
class+tuple_iterator
{
public:
++++tuple_iterator(Accessor+acc,+const+int+idx)
++++++++:+acc_(acc),+index_(idx)
++++{

++++}

++++tuple_iterator+operator%2B%2B()
++++{
++++++++%2B%2Bindex_;
++++++++return+*this;
++++}

++++template<typename+T>
++++bool+operator+==(tuple_iterator<T>+other)
++++{
++++++++return+index_+==+other.index();
++++}

++++template<typename+T>
++++bool+operator+!=(tuple_iterator<T>+other)
++++{
++++++++return+index_+!=+other.index();
++++}

++++auto+operator*()+{+return+std::invoke(acc_,+index_);+}

++++[[nodiscard]]+int+index()+const+{+return+index_;+}

private:
++++const+Accessor+acc_;
++++int+index_;
};

template<bool+IsConst,+typename...Ts>
struct+tuple_access
{
++++using+tuple_type+=+std::tuple<Ts...>;
++++using+tuple_ref+=+std::conditional_t<IsConst,+const+tuple_type&,+tuple_type&>;

++++template<typename+T>
++++using+element_ref+=+std::conditional_t<IsConst,
++++++++std::reference_wrapper<const+T>,
++++++++std::reference_wrapper<T>>;

++++using+variant_type+=+std::variant<element_ref<Ts>...>;
++++using+function_type+=+variant_type(*)(tuple_ref);
++++using+table_type+=+std::array<function_type,+sizeof...(Ts)>;

private:
++++template<size_t+Index>
++++static+constexpr+function_type+create_accessor()
++++{
++++++++return+{+[](tuple_ref+t)+->+variant_type
++++++++{
++++++++++++if+constexpr+(IsConst)
++++++++++++++++return+std::cref(std::get<Index>(t));
++++++++++++else
++++++++++++++++return+std::ref(std::get<Index>(t));
++++++++}+};
++++}

++++template<size_t...Is>
++++static+constexpr+table_type+create_table(std::index_sequence<Is...>)
++++{
++++++++return+{+create_accessor<Is>()...+};
++++}

public:
++++static+constexpr+auto+table+=+create_table(std::make_index_sequence<sizeof...(Ts)>{});+
};

template<bool+IsConst,+typename...Ts>
class+tuple_range
{
public:
++++using+tuple_access_type+=+tuple_access<IsConst,+Ts...>;
++++using+tuple_ref+=+typename+tuple_access_type::tuple_ref;

++++static+constexpr+auto+tuple_size+=+sizeof...(Ts);

++++explicit+tuple_range(tuple_ref+tuple)
++++++++:+tuple_(tuple)
++++{
++++}

++++[[nodiscard]]+auto+begin()+const+
++++{+
++++++++return+tuple_iterator{+create_accessor(),+0+};
++++}

++++[[nodiscard]]+auto+end()+const+
++++{+
++++++++return+tuple_iterator{+create_accessor(),+tuple_size+};
++++}

private:
++++tuple_ref+tuple_;

++++auto+create_accessor()+const
++++{+
++++++++return+[this](int+idx)
++++++++{
++++++++++++return+std::invoke(tuple_access_type::table[idx],+tuple_);
++++++++};
++++}
};

template<bool+IsConst,+typename...Ts>
auto+begin(const+tuple_range<IsConst,+Ts...>&+r)
{
++++return+r.begin();
}

template<bool+IsConst,+typename...Ts>
auto+end(const+tuple_range<IsConst,+Ts...>&+r)
{
++++return+r.end();
}

template+<class+...+Fs>
struct+overload+:+Fs...+{
++++explicit+overload(Fs&&...+fs)+:+Fs{+fs+}...+{}
++++using+Fs::operator()...;

++++template<class+T>
++++auto+operator()(std::reference_wrapper<T>+ref)
++++{
++++++++return+(*this)(ref.get());
++++}

++++template<class+T>
++++auto+operator()(std::reference_wrapper<const+T>+ref)
++++{
++++++++return+(*this)(ref.get());
++++}
};

template+<class+F>
struct+unwrap+:+overload<F>
{
++++explicit+unwrap(F&&+f)+:+overload<F>{+std::forward<F>(f)+}+{}
++++using+overload<F>::operator();
};

template<typename...Ts>
auto+to_range(std::tuple<Ts...>&+t)
{
++++return+tuple_range<false,+Ts...>{t};
}

template<typename...Ts>
auto+to_range(const+std::tuple<Ts...>&+t)
{
++++return+tuple_range<true,+Ts...>{t};
}


#endif|336053|还可以通过向to_range()传递const+std::tuple<>&来支持只读访问。|336054|entityMap|0|LINK|mutability|MUTABLE|url|https://foonathan.net/2017/03/tuple-iterator/^0|39|7|3H|5|4C|H|50|A|1R|19|0|0|0|0|0|0|6|A|I|J|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|F|3|G|5|6|7|1C|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1D|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1E|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1F|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1G|8|@$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

Another option would be to implement iterators for tuples. This has the advantage that you can use a variety of algorithms provided by the standard library and range-based for loops. An elegant approach to this is explained here <a href="https://foonathan.net/2017/03/tuple-iterator/" rel="nofollow noreferrer">https://foonathan.net/2017/03/tuple-iterator/</a>. The basic idea is to turn tuples into a range with <code>begin()</code> and <code>end()</code> methods to provide iterators. The iterator itself returns a <code>std::variant&lt;...&gt;</code> which can then be visited using <code>std::visit</code>. 

Here some examples:

<pre><code>auto t = std::tuple{ 1, 2.f, 3.0 };
auto r = to_range(t);

for(auto v : r)
{
 std::visit(unwrap([](auto&amp; x)
 {
 x = 1;
 }), v);
}

std::for_each(begin(r), end(r), [](auto v)
 {
 std::visit(unwrap([](auto&amp; x)
 {
 x = 0;
 }), v);
 });

std::accumulate(begin(r), end(r), 0.0, [](auto acc, auto v)
 {
 return acc + std::visit(unwrap([](auto&amp; x)
 {
 return static_cast&lt;double&gt;(x);
 }), v);
 });

std::for_each(begin(r), end(r), [](auto v)
{
 std::visit(unwrap([](const auto&amp; x)
 {
 std::cout &lt;&lt; x &lt;&lt; std::endl;
 }), v);
});

std::for_each(begin(r), end(r), [](auto v)
{
 std::visit(overload(
 [](int x) { std::cout &lt;&lt; "int" &lt;&lt; std::endl; },
 [](float x) { std::cout &lt;&lt; "float" &lt;&lt; std::endl; },
 [](double x) { std::cout &lt;&lt; "double" &lt;&lt; std::endl; }), v);
});
</code></pre>

My implementation (which is heavily based on the explanations in the link above):

<pre><code>#ifndef TUPLE_RANGE_H
#define TUPLE_RANGE_H

#include &lt;utility&gt;
#include &lt;functional&gt;
#include &lt;variant&gt;
#include &lt;type_traits&gt;

template&lt;typename Accessor&gt;
class tuple_iterator
{
public:
 tuple_iterator(Accessor acc, const int idx)
 : acc_(acc), index_(idx)
 {

 }

 tuple_iterator operator++()
 {
 ++index_;
 return *this;
 }

 template&lt;typename T&gt;
 bool operator ==(tuple_iterator&lt;T&gt; other)
 {
 return index_ == other.index();
 }

 template&lt;typename T&gt;
 bool operator !=(tuple_iterator&lt;T&gt; other)
 {
 return index_ != other.index();
 }

 auto operator*() { return std::invoke(acc_, index_); }

 [[nodiscard]] int index() const { return index_; }

private:
 const Accessor acc_;
 int index_;
};

template&lt;bool IsConst, typename...Ts&gt;
struct tuple_access
{
 using tuple_type = std::tuple&lt;Ts...&gt;;
 using tuple_ref = std::conditional_t&lt;IsConst, const tuple_type&amp;, tuple_type&amp;&gt;;

 template&lt;typename T&gt;
 using element_ref = std::conditional_t&lt;IsConst,
 std::reference_wrapper&lt;const T&gt;,
 std::reference_wrapper&lt;T&gt;&gt;;

 using variant_type = std::variant&lt;element_ref&lt;Ts&gt;...&gt;;
 using function_type = variant_type(*)(tuple_ref);
 using table_type = std::array&lt;function_type, sizeof...(Ts)&gt;;

private:
 template&lt;size_t Index&gt;
 static constexpr function_type create_accessor()
 {
 return { [](tuple_ref t) -&gt; variant_type
 {
 if constexpr (IsConst)
 return std::cref(std::get&lt;Index&gt;(t));
 else
 return std::ref(std::get&lt;Index&gt;(t));
 } };
 }

 template&lt;size_t...Is&gt;
 static constexpr table_type create_table(std::index_sequence&lt;Is...&gt;)
 {
 return { create_accessor&lt;Is&gt;()... };
 }

public:
 static constexpr auto table = create_table(std::make_index_sequence&lt;sizeof...(Ts)&gt;{}); 
};

template&lt;bool IsConst, typename...Ts&gt;
class tuple_range
{
public:
 using tuple_access_type = tuple_access&lt;IsConst, Ts...&gt;;
 using tuple_ref = typename tuple_access_type::tuple_ref;

 static constexpr auto tuple_size = sizeof...(Ts);

 explicit tuple_range(tuple_ref tuple)
 : tuple_(tuple)
 {
 }

 [[nodiscard]] auto begin() const 
 { 
 return tuple_iterator{ create_accessor(), 0 };
 }

 [[nodiscard]] auto end() const 
 { 
 return tuple_iterator{ create_accessor(), tuple_size };
 }

private:
 tuple_ref tuple_;

 auto create_accessor() const
 { 
 return [this](int idx)
 {
 return std::invoke(tuple_access_type::table[idx], tuple_);
 };
 }
};

template&lt;bool IsConst, typename...Ts&gt;
auto begin(const tuple_range&lt;IsConst, Ts...&gt;&amp; r)
{
 return r.begin();
}

template&lt;bool IsConst, typename...Ts&gt;
auto end(const tuple_range&lt;IsConst, Ts...&gt;&amp; r)
{
 return r.end();
}

template &lt;class ... Fs&gt;
struct overload : Fs... {
 explicit overload(Fs&amp;&amp;... fs) : Fs{ fs }... {}
 using Fs::operator()...;

 template&lt;class T&gt;
 auto operator()(std::reference_wrapper&lt;T&gt; ref)
 {
 return (*this)(ref.get());
 }

 template&lt;class T&gt;
 auto operator()(std::reference_wrapper&lt;const T&gt; ref)
 {
 return (*this)(ref.get());
 }
};

template &lt;class F&gt;
struct unwrap : overload&lt;F&gt;
{
 explicit unwrap(F&amp;&amp; f) : overload&lt;F&gt;{ std::forward&lt;F&gt;(f) } {}
 using overload&lt;F&gt;::operator();
};

template&lt;typename...Ts&gt;
auto to_range(std::tuple&lt;Ts...&gt;&amp; t)
{
 return tuple_range&lt;false, Ts...&gt;{t};
}

template&lt;typename...Ts&gt;
auto to_range(const std::tuple&lt;Ts...&gt;&amp; t)
{
 return tuple_range&lt;true, Ts...&gt;{t};
}


#endif
</code></pre>

Read-only access is also supported by passing a <code>const std::tuple&lt;&gt;&amp;</code> to <code>to_range()</code>.

blocks|key|334988|text|扩展@Stypox+answer，我们可以使他们的解决方案更通用(C%2B%2B17更高)。通过添加一个可调用的函数参数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|334989|template<size_t+I+=+0,+typename...+Tp,+typename+F>
void+for_each_apply(std::tuple<Tp...>&+t,+F+&&f)+{
++++f(std::get(t));
++++if+constexpr(I%2B1+!=+sizeof...(Tp))+{
++++++++for_each_apply<I%2B1>(t,+std::forward<F>(f));
++++}
}|code-block|syntax|javascript|334990|然后，我们需要一个访问每种类型的策略。|334991|让我们从一些帮助器开始(前两个取自cppreference)：|334992|template<class...+Ts>+struct+overloaded+:+Ts...+{+using+Ts::operator()...;+};
template<class...+Ts>+overloaded(Ts...)+->+overloaded<Ts...>;
template<class+...+Ts>+struct+variant_ref+{+using+type+=+std::variant<std::reference_wrapper<Ts>...>;+};|334993|variant_ref用于允许修改元组的状态。|offset|length|style|CODE|334994|用法：|334995|std::tuple<Foo,+Bar,+Foo>+tuples;

for_each_apply(tuples,
+++++++++++++++[](variant_ref<Foo,+Bar>::type+&&v)+{
+++++++++++++++++++std::visit(overloaded+{
+++++++++++++++++++++++[](Foo+&arg)+{+arg.foo();+},
+++++++++++++++++++++++[](Bar+const+&arg)+{+arg.bar();+},
+++++++++++++++++++},+v);
+++++++++++++++});|334996|结果：|334997|Foo0
Bar
Foo0
Foo1
Bar
Foo1|334998|为了完整起见，这里是我的Bar+&+Foo|334999|struct+Foo+{
++++void+foo()+{std::cout+<<+"Foo"+<<+i%2B%2B+<<+std::endl;}
++++int+i+=+0;
};
struct+Bar+{
++++void+bar()+const+{std::cout+<<+"Bar"+<<+std::endl;}
};|335000|entityMap^0|0|0|0|0|0|0|B|0|0|0|0|0|C|3|I|3|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|1B|8|@$O|1C|P|1D|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1I|8|@$O|1J|P|1K|Q|R]|$O|1L|P|1M|Q|R]]|9|@]|A|$]]|$1|12|3|13|5|D|7|1N|8|@]|9|@]|A|$E|F]]|$1|14|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|15|$]]

Expanding on @Stypox answer, we can make their solution more generic (C++17 onward). By adding a callable function argument:

<pre><code>template&lt;size_t I = 0, typename... Tp, typename F&gt;
void for_each_apply(std::tuple&lt;Tp...&gt;&amp; t, F &amp;&amp;f) {
 f(std::get&lt;I&gt;(t));
 if constexpr(I+1 != sizeof...(Tp)) {
 for_each_apply&lt;I+1&gt;(t, std::forward&lt;F&gt;(f));
 }
}
</code></pre>

Then, we need a strategy to visit each type.

Let start with some helpers (first two taken from cppreference):

<pre><code>template&lt;class... Ts&gt; struct overloaded : Ts... { using Ts::operator()...; };
template&lt;class... Ts&gt; overloaded(Ts...) -&gt; overloaded&lt;Ts...&gt;;
template&lt;class ... Ts&gt; struct variant_ref { using type = std::variant&lt;std::reference_wrapper&lt;Ts&gt;...&gt;; };
</code></pre>

<code>variant_ref</code> is used to allow tuples' state to be modified.

Usage:

<pre><code>std::tuple&lt;Foo, Bar, Foo&gt; tuples;

for_each_apply(tuples,
 [](variant_ref&lt;Foo, Bar&gt;::type &amp;&amp;v) {
 std::visit(overloaded {
 [](Foo &amp;arg) { arg.foo(); },
 [](Bar const &amp;arg) { arg.bar(); },
 }, v);
 });
</code></pre>

Result:

<pre><code>Foo0
Bar
Foo0
Foo1
Bar
Foo1
</code></pre>

For completeness, here are my <code>Bar</code> &amp; <code>Foo</code>:

<pre><code>struct Foo {
 void foo() {std::cout &lt;&lt; "Foo" &lt;&lt; i++ &lt;&lt; std::endl;}
 int i = 0;
};
struct Bar {
 void bar() const {std::cout &lt;&lt; "Bar" &lt;&lt; std::endl;}
};
</code></pre>

How can I iterate over a tuple (using C++11)? I tried the following:

<pre><code>for(int i=0; i&lt;std::tuple_size&lt;T...&gt;::value; ++i) 
 std::get&lt;i&gt;(my_tuple).do_sth();
</code></pre>

but this doesn't work:

<blockquote>
 Error 1: sorry, unimplemented: cannot expand ‘Listener ...’ into a fixed-length argument list. 
 Error 2: i cannot appear in a constant expression.
</blockquote>

So, how do I correctly iterate over the elements of a tuple?

How can you iterate over the elements of an std::tuple?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我如何迭代一个元组(使用C++11)？我尝试了以下几种方法：for(int i=0; i<std::tuple_size<T...>::value; ++i) std::get(my_tuple).do_sth();但这不起作用：错误1:对不起，未实现:无法展开‘Listener...’转换为固定长度的参数列...

问如何遍历std::tuple的元素？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何遍历std::tuple的元素？EN