blocks|key|1361564|text|您可以让迭代器调用一个函数，该函数在循环中的每次迭代中执行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1361565|查看此处：http://www.cplusplus.com/reference/algorithm/for_each/|offset|length|1361566|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cplusplus.com/reference/algorithm/for_each/^0|0|5|1I|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

You can have the iterator be a call to a function that is performed on each iteration through the loop.

See here:
<a href="http://www.cplusplus.com/reference/algorithm/for_each/" rel="nofollow noreferrer">http://www.cplusplus.com/reference/algorithm/for_each/</a>

blocks|key|1146622|text|for_each更通用。您可以使用它来迭代任何类型的容器(通过传入begin/end迭代器)。您可以在使用for_each的函数下潜在地交换容器，而不必更新迭代代码。您需要考虑到除了std::vector和普通的老式C数组之外，世界上还有其他容器，才能看到for_each的优势。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1146623|for_each的主要缺点是它需要一个函数器，因此语法很笨拙。通过引入lambda，这在C%2B%2B11+(以前的C%2B%2B0x)中得到了解决：|1146624|std::vector<int>+container;
...
std::for_each(container.begin(),+container.end(),+[](int&+i){
++++i%2B=+10;
});|code-block|syntax|javascript|1146625|3年后你就不会觉得奇怪了。|1146626|entityMap^0|0|8|1H|8|2J|B|3K|8|0|0|8|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|P|$]]

<code>for_each</code> is more generic. You can use it to iterate over any type of container (by passing in the begin/end iterators). You can potentially swap out containers underneath a function which uses <code>for_each</code> without having to update the iteration code. You need to consider that there are other containers in the world than <code>std::vector</code> and plain old C arrays to see the advantages of <code>for_each</code>.

The major drawback of <code>for_each</code> is that it takes a functor, so the syntax is clunky. This is fixed in C++11 (formerly C++0x) with the introduction of lambdas:

<pre><code>std::vector&lt;int&gt; container;
...
std::for_each(container.begin(), container.end(), [](int&amp; i){
 i+= 10;
});
</code></pre>

This will not look weird to you in 3 years.

blocks|key|1146682|text|for是for循环，可以迭代每个元素或每隔三个元素迭代一次。for_each只迭代每个元素。从它的名字中可以清楚地看出。因此，您在代码中想要做什么就会变得更加清晰。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1146683|entityMap^0|0|3|U|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

<code>for</code> is for loop that can iterate each element or every third etc. <code>for_each</code> is for iterating only each element. It is clear from its name. So it is more clear what you are intending to do in your code.

blocks|key|1361844|text|for_each循环的目的是对用户代码隐藏迭代器(循环如何实现的细节)，并在操作上定义清晰的语义:每个元素将只迭代一次。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1361845|当前标准的可读性问题是，它需要一个functor作为最后一个参数，而不是一段代码，因此在许多情况下，您必须为它编写特定的functor类型。这会导致代码可读性降低，因为函数器对象不能就地定义(函数中定义的本地类不能用作模板参数)，循环的实现必须从实际的循环中移出。|1361846|struct+myfunctor+{
+++void+operator()(+int+arg1+)+{+code+}
};
void+apply(+std::vector<int>+const+&+v+)+{
+++//+code
+++std::for_each(+v.begin(),+v.end(),+myfunctor()+);
+++//+more+code
}|code-block|syntax|javascript|1361847|请注意，如果您想对每个对象执行特定的操作，可以使用std::mem_fn或boost::bind+(下一个标准中的std::bind)或boost::lambda+(下一个标准中的lambdas)来使操作更简单：|1361848|void+function(+int+value+);
void+apply(+std::vector<X>+const+&+v+)+{
+++//+code
+++std::for_each(+v.begin(),+v.end(),+boost::bind(+function,+_1+)+);
+++//+code
}|1361849|如果你有要调用的函数/方法，它的可读性和紧凑性都不会比手写版本差。该实现可以提供for_each循环的其他实现(考虑并行处理)。|1361850|即将到来的标准以不同的方式解决了一些缺点，它将允许将本地定义的类作为模板的参数：|1361851|void+apply(+std::vector<int>+const+&+v+)+{
+++//+code
+++struct+myfunctor+{
++++++void+operator()(+int+)+{+code+}
+++};
+++std::for_each(+v.begin(),+v.end(),+myfunctor()+);
+++//+code
}|1361852|改善代码的局部性:当你浏览的时候，你会看到它正在做什么。事实上，您甚至不需要使用类语法来定义functor，而是直接使用lambda：|1361853|void+apply(+std::vector<int>+const+&+v+)+{
+++//+code
+++std::for_each(+v.begin(),+v.end(),+
++++++[](+int+)+{+//+code+}+);
+++//+code
}|1361854|即使对于for_each的情况，会有一个特定的构造，使它更自然：|1361855|void+apply(+std::vector<int>+const+&+v+)+{
+++//+code
+++for+(+int+i+:+v+)+{
++++++//+code
+++}
+++//+code
}|1361856|我倾向于将for_each结构与手动循环混合在一起。当我只需要对现有函数或方法的调用(for_each(+v.begin(),+v.end(),+boost::bind(+&Type::update,+_1+)+))时，我会使用for_each构造，它从代码中去掉了很多样板迭代器的东西。当我需要一些更复杂的东西，并且我不能实现一个仅仅比实际使用高出几行的functor时，我会滚动我自己的循环(保持操作在适当的位置)。在代码的非关键部分，我可能会使用BOOST_FOREACH+(一个同事让我这么做的)|1361857|entityMap^0|0|8|0|0|0|P|B|11|B|1L|9|1W|D|0|0|14|8|0|0|0|0|0|4|8|0|0|5|8|17|1S|36|8|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1B|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1M|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|U|3|V|5|J|7|1R|8|@]|D|@]|E|$K|L]]|$1|W|3|X|5|6|7|1S|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|J|7|1T|8|@]|D|@]|E|$K|L]]|$1|10|3|11|5|6|7|1U|8|@$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|12|3|13|5|J|7|1X|8|@]|D|@]|E|$K|L]]|$1|14|3|15|5|6|7|1Y|8|@$9|1Z|A|20|B|C]|$9|21|A|22|B|C]|$9|23|A|24|B|C]]|D|@]|E|$]]|$1|16|3|-4|5|6|7|25|8|@]|D|@]|E|$]]]|17|$]]

The <code>for_each</code> loop is meant to hide the iterators (detail of how a loop is implemented) from the user code and define clear semantics on the operation: each element will be iterated exactly once.

The problem with readability in the current standard is that it requires a functor as the last argument instead of a block of code, so in many cases you must write specific functor type for it. That turns into less readable code as functor objects cannot be defined in-place (local classes defined within a function cannot be used as template arguments) and the implementation of the loop must be moved away from the actual loop.

<pre><code>struct myfunctor {
 void operator()( int arg1 ) { code }
};
void apply( std::vector&lt;int&gt; const &amp; v ) {
 // code
 std::for_each( v.begin(), v.end(), myfunctor() );
 // more code
}
</code></pre>

Note that if you want to perform an specific operation on each object, you can use <code>std::mem_fn</code>, or <code>boost::bind</code> (<code>std::bind</code> in the next standard), or <code>boost::lambda</code> (lambdas in the next standard) to make it simpler:

<pre><code>void function( int value );
void apply( std::vector&lt;X&gt; const &amp; v ) {
 // code
 std::for_each( v.begin(), v.end(), boost::bind( function, _1 ) );
 // code
}
</code></pre>

Which is not less readable and more compact than the hand rolled version if you do have function/method to call in place. The implementation could provide other implementations of the <code>for_each</code> loop (think parallel processing).

The upcoming standard takes care of some of the shortcomings in different ways, it will allow for locally defined classes as arguments to templates:

<pre><code>void apply( std::vector&lt;int&gt; const &amp; v ) {
 // code
 struct myfunctor {
 void operator()( int ) { code }
 };
 std::for_each( v.begin(), v.end(), myfunctor() );
 // code
}
</code></pre>

Improving the locality of code: when you browse you see what it is doing right there. As a matter of fact, you don't even need to use the class syntax to define the functor, but use a lambda right there:

<pre><code>void apply( std::vector&lt;int&gt; const &amp; v ) {
 // code
 std::for_each( v.begin(), v.end(), 
 []( int ) { // code } );
 // code
}
</code></pre>

Even if for the case of <code>for_each</code> there will be an specific construct that will make it more natural:

<pre><code>void apply( std::vector&lt;int&gt; const &amp; v ) {
 // code
 for ( int i : v ) {
 // code
 }
 // code
}
</code></pre>

I tend to mix the <code>for_each</code> construct with hand rolled loops. When only a call to an existing function or method is what I need (<code>for_each( v.begin(), v.end(), boost::bind( &amp;Type::update, _1 ) )</code>) I go for the <code>for_each</code> construct that takes away from the code a lot of boiler plate iterator stuff. When I need something more complex and I cannot implement a functor just a couple of lines above the actual use, I roll my own loop (keeps the operation in place). In non-critical sections of code I might go with BOOST_FOREACH (a co-worker got me into it)

blocks|key|1361903|text|就我个人而言，每当我需要使用std::for_each+(编写特殊用途的函数器/复杂的boost::lambda)时，我发现BOOST_FOREACH和C%2B%2B0x的范围更清晰：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1361904|BOOST_FOREACH(Monster*+m,+monsters)+{
+++++if+(m->has_plan())+
+++++++++m->act();
}|code-block|syntax|javascript|1361905|vs|1361906|std::for_each(monsters.begin(),+monsters.end(),+
++if_then(bind(&Monster::has_plan,+_1),+
++++bind(&Monster::act,+_1)));|1361907|entityMap^0|E|D|17|D|1Q|D|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

Personally, any time I'd need to go out of my way to use <code>std::for_each</code> (write special-purpose functors / complicated <code>boost::lambda</code>s), I find <code>BOOST_FOREACH</code> and C++0x's range-based for clearer:

<pre><code>BOOST_FOREACH(Monster* m, monsters) {
 if (m-&gt;has_plan()) 
 m-&gt;act();
}
</code></pre>

vs

<pre><code>std::for_each(monsters.begin(), monsters.end(), 
 if_then(bind(&amp;Monster::has_plan, _1), 
 bind(&amp;Monster::act, _1)));
</code></pre>

blocks|key|1146909|text|除了可读性和性能之外，通常被忽视的一个方面是一致性。有许多方法可以在迭代器上实现for+(或while)循环，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1146910|for+(C::iterator+iter+=+c.begin();+iter+!=+c.end();+iter%2B%2B)+{
++++do_something(*iter);
}|code-block|syntax|javascript|1146911|至：|1146912|C::iterator+iter+=+c.begin();
C::iterator+end+=+c.end();
while+(iter+!=+end)+{
++++do_something(*iter);
++++%2B%2Biter;
}|1146913|中间有许多不同级别的效率和潜在bug的示例。|1146914|然而，使用for_each，通过抽象出循环来加强一致性：|1146915|for_each(c.begin(),+c.end(),+do_something);|1146916|现在你唯一需要担心的是:你使用Boost或C%2B%2B0x特性将循环体实现为函数、函数器还是lambda？就我个人而言，我更愿意担心这一点，而不是如何实现或读取随机的for/while循环。|1146917|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Aside from readability and performance, one aspect commonly overlooked is consistency. There are many ways to implement a for (or while) loop over iterators, from:

<pre><code>for (C::iterator iter = c.begin(); iter != c.end(); iter++) {
 do_something(*iter);
}
</code></pre>

to:

<pre><code>C::iterator iter = c.begin();
C::iterator end = c.end();
while (iter != end) {
 do_something(*iter);
 ++iter;
}
</code></pre>

with many examples in between at varying levels of efficiency and bug potential.

Using for_each, however, enforces consistency by abstracting away the loop:

<pre><code>for_each(c.begin(), c.end(), do_something);
</code></pre>

The only thing you have to worry about now is: do you implement the loop body as function, a functor, or a lambda using Boost or C++0x features? Personally, I'd rather worry about that than how to implement or read a random for/while loop.

blocks|key|1362009|text|我发现for_each不利于可读性。这是一个很好的概念，但是c%2B%2B使得它很难写成可读的，至少对我来说是这样。c%2B%2B0x+lamda表达式将会有所帮助。我真的很喜欢lamdas的想法。然而，乍一看，我认为它的语法非常丑陋，我不能百分之百地确定我会不会习惯它。也许5年后我就会习惯它，不会再去想它，但也可能不会。时间会告诉我们的:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1362010|我更喜欢用|1362011|vector<thing>::iterator+istart+=+container.begin();
vector<thing>::iterator+iend+=+container.end();
for(vector<thing>::iterator+i+=+istart;+i+!=+iend;+%2B%2Bi)+{
++//+Do+stuff
}|code-block|syntax|javascript|1362012|我发现显式的for循环读起来更清晰，并且显式地为start和end迭代器使用命名变量减少了for循环中的混乱。|1362013|当然，情况会有所不同，这是我通常找到的最好的。|1362014|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I find for_each to be bad for readability. The concept is a good one but c++ makes it very hard to write readable, at least for me. c++0x lamda expressions will help. I really like the idea of lamdas. However on first glance I think the syntax is very ugly and I'm not 100% sure I'll ever get used to it. Maybe in 5 years I'll have got used to it and not give it a second thought, but maybe not. Time will tell :)

I prefer to use

<pre><code>vector&lt;thing&gt;::iterator istart = container.begin();
vector&lt;thing&gt;::iterator iend = container.end();
for(vector&lt;thing&gt;::iterator i = istart; i != iend; ++i) {
 // Do stuff
}
</code></pre>

I find an explicit for loop clearer to read and explicity using named variables for the start and end iterators reduces the clutter in the for loop.

Of course cases vary, this is just what I usually find best.

blocks|key|1362049|text|For循环可能会中断；我不想成为Herb+Sutter的一只鹦鹉，所以这里是他的演示文稿的链接：http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-835T，请务必也阅读评论:)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1362050|entityMap|0|LINK|mutability|MUTABLE|url|http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-835T^0|1C|1L|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

For loop can break; 
I dont want to be a parrot for Herb Sutter so here is the link to his presentation:
<a href="http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-835T" rel="nofollow">http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-835T</a>
Be sure to read the comments also :)

blocks|key|1362099|text|简单:当您已经有一个处理每个数组项的函数时，for_each很有用，这样您就不必编写lambda了。当然，这是|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1362100|for_each(a.begin(),+a.end(),+a_item_handler);|code-block|syntax|javascript|1362101|比|1362102|for(auto&+item:+a)+{
++++a_item_handler(a);
}|1362103|而且，for_each更加灵活，ranged+for循环只会从头到尾遍历整个容器。|1362104|entityMap^0|M|8|0|0|0|0|3|8|N|3|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

Easy: <code>for_each</code> is useful when you already have a function to handle every array item, so you don't have to write a lambda. Certainly, this

<pre><code>for_each(a.begin(), a.end(), a_item_handler);
</code></pre>

is better than

<pre><code>for(auto&amp; item: a) {
 a_item_handler(a);
}
</code></pre>

Also, ranged <code>for</code> loop only iterates over whole containers from start to end, whilst <code>for_each</code> is more flexible.

blocks|key|1147124|text|for_each允许我们实现Fork-Join+pattern。除此之外，它还支持fluent-interface。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1147125|fork-join模式|1147126|我们可以通过在多个workers中调用lambda任务来添加实现gpu::for_each，以使用cuda/gpu进行异构并行计算。|1147127|gpu::for_each(users.begin(),users.end(),update_summary);
//+all+summary+is+complete+now
//+go+access+the+user-summary+here.|code-block|syntax|javascript|1147128|并且在执行下一条语句之前，gpu::for_each可以等待工作者完成对所有λ任务的工作。|1147129|流畅的界面|1147130|它允许我们以简洁方式编写人类可读的代码。|1147131|accounts::erase(std::remove_if(accounts.begin(),accounts.end(),used_this_year));
std::for_each(accounts.begin(),accounts.end(),mark_dormant);|1147132|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Fork%25E2%2580%2593join_model|1|https://en.wikipedia.org/wiki/Fluent_interface^0|0|8|E|H|0|15|G|1|0|0|W|D|0|0|D|D|0|0|0|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|6|7|1F|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|1J|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1N|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1O|8|@]|D|@]|E|$]]|$1|U|3|V|5|L|7|1P|8|@]|D|@]|E|$M|N]]|$1|W|3|-4|5|6|7|1Q|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]|14|$5|Z|10|11|E|$12|15]]]]

<code>for_each</code> allow us to implement <a href="https://en.wikipedia.org/wiki/Fork%E2%80%93join_model" rel="nofollow noreferrer">Fork-Join pattern</a> . Other than that it supports <a href="https://en.wikipedia.org/wiki/Fluent_interface" rel="nofollow noreferrer">fluent-interface</a>. 

<h1>fork-join pattern</h1>

We can add implementation <code>gpu::for_each</code> to use cuda/gpu for heterogeneous-parallel computing by calling the lambda task in multiple workers.

<pre><code>gpu::for_each(users.begin(),users.end(),update_summary);
// all summary is complete now
// go access the user-summary here.
</code></pre>

And <code>gpu::for_each</code> may wait for the workers work on all the lambda-tasks to finish before executing the next statements.

<h1>fluent-interface</h1>

It allow us to write human-readable code in concise manner.

<pre><code>accounts::erase(std::remove_if(accounts.begin(),accounts.end(),used_this_year));
std::for_each(accounts.begin(),accounts.end(),mark_dormant);
</code></pre>

blocks|key|1362241|text|在其他答案中有很多很好的理由，但似乎都忘记了，当for循环总是以begin()迭代器开始时，for_each允许您使用反向或几乎任何自定义迭代器。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1362242|使用反向迭代器的示例：|1362243|std::list<int>+l+{1,2,3};
std::for_each(l.rbegin(),+l.rend(),+[](auto+o){std::cout<<o;});|code-block|syntax|javascript|1362244|使用一些自定义树迭代器的示例：|1362245|SomeCustomTree<int>+a{1,2,3,4,5,6,7};
auto+node+=+a.find(4);
std::for_each(node.breadthFirstBegin(),+node.breadthFirstEnd(),+[](auto+o){std::cout<<o;});|1362246|entityMap^0|W|7|1A|8|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

There are a lot of good reasons in other answers but all seem to forget that
<code>for_each</code> allows you to use reverse or pretty much any custom iterator when for loop always starts with <code>begin()</code> iterator.
Example with reverse iterator:
<pre><code>std::list&lt;int&gt; l {1,2,3};
std::for_each(l.rbegin(), l.rend(), [](auto o){std::cout&lt;&lt;o;});
</code></pre>
Example with some custom tree iterator:
<pre><code>SomeCustomTree&lt;int&gt; a{1,2,3,4,5,6,7};
auto node = a.find(4);
std::for_each(node.breadthFirstBegin(), node.breadthFirstEnd(), [](auto o){std::cout&lt;&lt;o;});
</code></pre>

Are there any advantages of <a href="http://en.cppreference.com/w/cpp/algorithm/for_each" rel="noreferrer"><code>std::for_each</code></a> over <code>for</code> loop? To me, <code>std::for_each</code> only seems to hinder the readability of code. Why do then some coding standards recommend its use?

Advantages of std::for_each over for loop

容器

与for循环相比，有什么优势吗？对我来说，std::for_each似乎只是阻碍了代码的可读性。那么为什么一些编码标准推荐使用它呢？

问std::for_each相对于for循环的优势
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问std::for_each相对于for循环的优势EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问std::for_each相对于for循环的优势
EN