blocks|key|1420351|text|它相当于|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1420352|while+(x--+>+0)|code-block|syntax|javascript|1420353|x--+(递减后)等同于x+=+x-1，因此，代码转换为：|offset|length|style|CODE|1420354|while(x+>+0)+{
++++x+=+x-1;
++++//+logic
}
x--;+++//+The+post+decrement+done+when+x+<=+0|1420355|entityMap^0|0|0|0|3|C|7|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

It's equivalent to

<pre><code>while (x-- &gt; 0)
</code></pre>

<code>x--</code> (post decrement) is equivalent to <code>x = x-1</code> so, the code transforms to:

<pre><code>while(x &gt; 0) {
 x = x-1;
 // logic
}
x--; // The post decrement done when x &lt;= 0
</code></pre>

blocks|key|1205403|text|它是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1205404|#include+<stdio.h>

int+main(void)+{
++int+x+=+10;
++while+(x--+>+0)+{+//+x+goes+to+0
++++printf("%25d+",+x);
++}
++return+0;
}|code-block|syntax|javascript|1205405|仅仅是空格就让事情看起来很滑稽，--递减和>比较。|offset|length|style|CODE|1205406|entityMap^0|0|0|G|2|L|1|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]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

It's
<pre><code>#include &lt;stdio.h&gt;

int main(void) {
 int x = 10;
 while (x-- &gt; 0) { // x goes to 0
 printf(&quot;%d &quot;, x);
 }
 return 0;
}
</code></pre>
Just the space makes the things look funny, <code>--</code> decrements and <code>&gt;</code> compares.

blocks|key|1205424|text|while(+x--+>+0+)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1205425|它是如何被解析的。|unstyled|1205426|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>while( x-- &gt; 0 )
</code></pre>

is how that's parsed.

blocks|key|1420476|text|这是一个非常复杂的运算符，因此即使是ISO/IEC+JTC1+(Joint+Technical+Committee+1)也将其描述放在C%2B%2B标准的两个不同部分中。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1420477|开玩笑的是，它们是两个不同的运算符：--和>，分别在C%2B%2B03标准的§5.2.6/2和§5.9中描述。|style|CODE|1420478|entityMap|0|LINK|mutability|MUTABLE|url|https://isocpp.org/std/the-committee^0|I|16|0|0|I|2|L|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@$A|U|B|V|F|G]|$A|W|B|X|F|G]]|9|@]|C|$]]|$1|H|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

That's a very complicated operator, so even <a href="https://isocpp.org/std/the-committee" rel="noreferrer">ISO/IEC JTC1 (Joint Technical Committee 1)</a> placed its description in two different parts of the C++ Standard.

Joking aside, they are two different operators: <code>--</code> and <code>&gt;</code> described respectively in &sect;5.2.6/2 and &sect;5.9 of the C++03 Standard.

blocks|key|1420529|text|不管怎样，我们现在有了一个“to+to”运算符。"-->"很容易被记住是一个方向，而"while+x+goes+to+zero“是直接的意思。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1420530|此外，在某些平台上，它比"for+(x+=+10;+x+>+0;+x+--)"更有效一些。|1420531|entityMap^0|O|5|0|C|R|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

Anyway, we have a "goes to" operator now. <code>"--&gt;"</code> is easy to be remembered as a direction, and "while x goes to zero" is meaning-straight.

Furthermore, it is a little more efficient than <code>"for (x = 10; x &gt; 0; x --)"</code> on some platforms.

blocks|key|1205646|text|-->的使用具有历史相关性。减少曾经(在某些情况下仍然是)，比在x86架构上增加更快。使用-->表明x将走向0，并吸引那些具有数学背景的人。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1205647|entityMap^0|0|3|19|3|1E|1|1I|1|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

The usage of <code>--&gt;</code> has historical relevance. Decrementing was (and still is in some cases), faster than incrementing on the x86 architecture. Using <code>--&gt;</code> suggests that <code>x</code> is going to <code>0</code>, and appeals to those with mathematical backgrounds.

blocks|key|1205693|text|这段代码首先比较x和0，然后递减x。(在第一个答案中也是这样说的:您在后递减x，然后使用>运算符比较x和0。)请参阅此代码的输出：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1205694|9+8+7+6+5+4+3+2+1+0|code-block|syntax|javascript|1205695|我们现在首先比较，然后通过在输出中看到0来递减。|1205696|如果我们想先减后比较，使用下面的代码：|1205697|#include+<stdio.h>
int+main(void)
{
++++int+x+=+10;

++++while(+--x>+0+)+//+x+goes+to+0
++++{
++++++++printf("%25d+",+x);
++++}
++++return+0;
}|1205698|该输出为：|1205699|9+8+7+6+5+4+3+2+1|1205700|entityMap^0|18|1|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|13|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|U|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|V|$]]

This code first compares x and 0 and then decrements x. (Also said in the first answer: You're post-decrementing x and then comparing x and 0 with the <code>&gt;</code> operator.) See the output of this code:

<pre><code>9 8 7 6 5 4 3 2 1 0
</code></pre>

We now first compare and then decrement by seeing 0 in the output.

If we want to first decrement and then compare, use this code:

<pre><code>#include &lt;stdio.h&gt;
int main(void)
{
 int x = 10;

 while( --x&gt; 0 ) // x goes to 0
 {
 printf("%d ", x);
 }
 return 0;
}
</code></pre>

That output is:

<pre><code>9 8 7 6 5 4 3 2 1
</code></pre>

blocks|key|1205769|text|--和>之间缺少一个空格。x后递减，即在检查条件x>0+?之后递减。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1205770|entityMap^0|0|2|3|1|D|1|O|5|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

There is a space missing between <code>--</code> and <code>&gt;</code>. <code>x</code> is post decremented, that is, decremented after checking the condition <code>x&gt;0 ?</code>.

blocks|key|1205805|text|这与|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1205806|while+(x--)|code-block|syntax|javascript|1205807|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|$]]

This is exactly the same as
<pre><code>while (x--)
</code></pre>

blocks|key|1205854|text|当我运行这段代码时，我的编译器将输出9876543210。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1205855|#include+<iostream>
int+main()
{
++++int+x+=+10;

++++while(+x+-->+0+)+//+x+goes+to+0
++++{
++++++++std::cout+<<+x;
++++}
}|code-block|syntax|javascript|1205856|不出所料。while(+x--+>+0+)实际上指的是while(+x+>+0)。x--+post会使x递减。|offset|length|style|CODE|1205857|while(+x+>+0+)+
{
++++x--;
++++std::cout+<<+x;
}|1205858|是一种不同的方式来写同样的东西。|1205859|虽然原文看起来像"while+x+to+to+0“，但这很好。|1205860|entityMap^0|0|0|5|G|R|D|15|3|1F|1|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|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]]|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|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|T|$]]

My compiler will print out 9876543210 when I run this code.

<pre><code>#include &lt;iostream&gt;
int main()
{
 int x = 10;

 while( x --&gt; 0 ) // x goes to 0
 {
 std::cout &lt;&lt; x;
 }
}
</code></pre>

As expected. The <code>while( x-- &gt; 0 )</code> actually means <code>while( x &gt; 0)</code>. The <code>x--</code> post decrements <code>x</code>.

<pre><code>while( x &gt; 0 ) 
{
 x--;
 std::cout &lt;&lt; x;
}
</code></pre>

is a different way of writing the same thing.

It is nice that the original looks like "while x goes to 0" though.

blocks|key|1205881|text|完全是极客，但我将使用这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1205882|#define+as+;while

int+main(int+argc,+char*+argv[])
{
++++int+n+=+atoi(argv[1]);
++++do+printf("n+is+%25d\n",+n)+as+(+n+-->+0);
++++return+0;
}|code-block|syntax|javascript|1205883|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|$]]

Utterly geek, but I will be using this:

<pre><code>#define as ;while

int main(int argc, char* argv[])
{
 int n = atoi(argv[1]);
 do printf("n is %d\n", n) as ( n --&gt; 0);
 return 0;
}
</code></pre>

blocks|key|1205925|text|或者为了一些完全不同的东西。x幻灯片到0。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1205926|while+(x+--\
++++++++++++\
+++++++++++++\
++++++++++++++\
+++++++++++++++>+0)
+++++printf("%25d+",+x);|code-block|syntax|javascript|1205927|不是很数学，但是..。每一幅画都描绘了千言万语。|1205928|entityMap^0|E|1|J|1|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Or for something completely different... <code>x</code> slides to <code>0</code>.

<pre><code>while (x --\
 \
 \
 \
 &gt; 0)
 printf("%d ", x);
</code></pre>

Not so mathematical, but... every picture paints a thousand words...

blocks|key|1205953|text|实际上，x是后递减的，并且正在检查该条件。不是-->，是(x--)+>+0|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1205954|注意:检查完条件后，x的值会发生变化，因为它是后减的。一些类似的情况也可能发生，例如：|1205955|-->++++x-->0
%2B%2B>++++x%2B%2B>0
-->=+++x-->=0
%2B%2B>=+++x%2B%2B>=0|code-block|syntax|javascript|1205956|entityMap^0|4|1|N|3|S|9|0|A|1|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|N|$]]

Actually, <code>x</code> is post-decrementing and with that condition is being checked. It's not <code>--&gt;</code>, it's <code>(x--) &gt; 0</code>

Note: value of <code>x</code> is changed after the condition is checked, because it post-decrementing. Some similar cases can also occur, for example:

<pre><code>--&gt; x--&gt;0
++&gt; x++&gt;0
--&gt;= x--&gt;=0
++&gt;= x++&gt;=0
</code></pre>

blocks|key|1421016|text|它是两个运算符的组合。First+--用于递减该值，>用于检查该值是否大于右操作数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1421017|#include<stdio.h>

int+main()
{
++++int+x+=+10;

++++while+(x--+>+0)
++++++++printf("%25d+",x);

++++return+0;
}|code-block|syntax|javascript|1421018|输出将为：|1421019|9+8+7+6+5+4+3+2+1+0++++++++++++|1421020|entityMap^0|H|2|Q|1|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]]|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|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

It's a combination of two operators. First <code>--</code> is for decrementing the value, and <code>&gt;</code> is for checking whether the value is greater than the right-hand operand.

<pre><code>#include&lt;stdio.h&gt;

int main()
{
 int x = 10;

 while (x-- &gt; 0)
 printf("%d ",x);

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

The output will be:

<pre><code>9 8 7 6 5 4 3 2 1 0 
</code></pre>

blocks|key|1206013|text|C和C%2B%2B遵守“最大吞食”规则。与a-b转换为(a--)+-+b的方式相同，在本例中，x-->0转换为(x--)>0。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1206014|这条规则本质上是说，从左到右，表达式是由最多的字符组成的，这将形成一个有效的表达式。|1206015|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/C_%2528programming_language%2529|1|https://en.wikipedia.org/wiki/C%2B%2B^0|N|9|17|5|1F|7|0|1|0|2|3|1|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@$9|Y|A|Z|1|10]|$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

<a href="http://en.wikipedia.org/wiki/C_%28programming_language%29">C</a> and <a href="https://en.wikipedia.org/wiki/C++">C++</a> obey the "maximum munch" rule. The same way a---b is translated to <code>(a--) - b</code>, in your case <code>x--&gt;0</code> translates to <code>(x--)&gt;0</code>.

What the rule says essentially is that going left to right, expressions are formed by taking the maximum of characters which will form an valid expression.

blocks|key|1206044|text|x可以在相反的方向上更快地归零：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1206045|int+x+=+10;

while(+0+<----+x+)
{
+++printf("%25d+",+x);
}|code-block|syntax|javascript|1206046|8+6+4+2|1206047|你可以用箭头控制速度！|1206048|int+x+=+100;

while(+0+<--------------------+x+)
{
+++printf("%25d+",+x);
}|1206049|90+80+70+60+50+40+30+20+10|1206050|;)|1206051|entityMap^0|0|1|0|0|0|7|0|0|0|0|Q|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|13|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|18|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|V|$]]

<code>x</code> can go to zero even faster in the opposite direction:

<pre><code>int x = 10;

while( 0 &lt;---- x )
{
 printf("%d ", x);
}
</code></pre>

<code>8 6 4 2</code>

You can control speed with an arrow!

<pre><code>int x = 100;

while( 0 &lt;-------------------- x )
{
 printf("%d ", x);
}
</code></pre>

<code>90 80 70 60 50 40 30 20 10</code>

;)

blocks|key|1206134|text|为什么这么复杂？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1206135|对原问题的简单答案是：|1206136|#include+<stdio.h>

int+main()
{
++++int+x+=+10;
++++while+(x+>+0)
++++{
++++++++printf("%25d+",+x);
++++++++x+=+x-1;
++++}
}|code-block|syntax|javascript|1206137|它做的是同样的事情。我并不是说你应该这样做，但它做了同样的事情，并且会在一个帖子中回答这个问题。|1206138|x--只是上述内容的简写，而>只是一个比operator更大的普通版本。没什么神秘的！|offset|length|style|CODE|1206139|现在有太多的人让简单的事情变得复杂;)|1206140|entityMap^0|0|0|0|0|0|3|E|1|K|8|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|Y|8|@$M|Z|N|10|O|P]|$M|11|N|12|O|P]|$M|13|N|14|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|T|$]]

Why all the complication?
The simple answer to the original question is just:
<pre><code>#include &lt;stdio.h&gt;

int main()
{
 int x = 10;
 while (x &gt; 0)
 {
 printf(&quot;%d &quot;, x);
 x = x-1;
 }
}
</code></pre>
It does the same thing. I am not saying you should do it like this, but it does the same thing and would have answered the question in one post.
The <code>x--</code> is just shorthand for the above, and <code>&gt;</code> is just a normal greater-than <code>operator</code>. No big mystery!
There are too many people making simple things complicated nowadays ;)

blocks|key|1206222|text|传统的方法是在while循环的圆括号“()”中定义条件，在大括号“{}”中定义终止条件，但是这个--+&+>是一种一次性定义所有条件的方法。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1206223|int+abc(){
++++int+a+=+5
++++while((a--)+>+0){+//+Decrement+and+comparison+both+at+once
++++++++//+Code
++++}
}|code-block|syntax|javascript|1206224|它说，递减a并运行循环，直到时间a大于0|1206225|另一种方式应该是这样的：|1206226|int+abc()+{
++++int+a+=+5;
++++while(a+>+0)+{
++++++++a+=+a+-1+//+Decrement+inside+loop
++++++++//+Code
++++}
}|1206227|两种方式，我们做同样的事情，实现同样的目标。|1206228|entityMap^0|J|2|X|2|1C|2|1H|1|0|0|5|1|G|1|J|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$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|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1B|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1D|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|T|$]]

Conventional way we define condition in while loop parenthesis&quot;<code>()</code>&quot; and terminating condition inside the braces&quot;<code>{}</code>&quot;, but this <code>--</code> &amp; <code>&gt;</code> is a way one defines all at once.
For example:
<pre><code>int abc(){
 int a = 5
 while((a--) &gt; 0){ // Decrement and comparison both at once
 // Code
 }
}
</code></pre>
It says, decrement <code>a</code> and run the loop till the time <code>a</code> is greater than <code>0</code>
Other way it should have been like:
<pre><code>int abc() {
 int a = 5;
 while(a &gt; 0) {
 a = a -1 // Decrement inside loop
 // Code
 }
}
</code></pre>
Both ways, we do the same thing and achieve the same goals.

blocks|key|1421361|text|char+sep+=+'\n'++/1\
;+int+i+=+68++++/1++\
;+while+(i++---++++++1\
+++++++++++++++++++++++\
+++++++++++++++++++++++/1/1/1+++++++++++++++++++++++++++++++/1\
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/1\
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/1\
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/1\
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/1\
++++++++++++++++++++++++++++/+++++++++++1\
+++++++++++++++++++++++++++/++++++++++++1+\
++++++++++++++++++++++++++/+++++++++++++1++\
+++++++++++++++++++++++++/++++++++++++++1+++\
+++++++++++++++++++++++++/1++++++++++++/1++++\
++++++++++++++++++++++++++/1++++++++++/1++++++\
+++++++++++++++++++++++++++/1++++++++/1++++++++/1/1>+0)+std::cout+\
++++++++++++++++++++++++++++++<<i<<+++++++++++++++++++++++++++++++sep;|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1421362|对于更大的数字，C%2B%2B20引入了一些更高级的循环特性。首先，为了捕获i，我们可以构建一个反向循环-反循环并将其偏转到std::ostream上。但是，i的速度是由实现定义的，因此我们可以使用新的C%2B%2B20速度运算符<<i<<来加快速度。我们还必须通过构建墙来捕获它，如果我们不这样做，i会离开作用域，取消对它的引用会导致未定义的行为。要指定分隔符，我们可以使用：|unstyled|offset|length|style|CODE|1421363|+std::cout+\
+++++++++++sep|1421364|我们有一个从67到1的for循环。|1421365|entityMap^0|0|Y|1|1M|C|23|1|2Z|5|3Y|1|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@$G|S|H|T|I|J]|$G|U|H|V|I|J]|$G|W|H|X|I|J]|$G|Y|H|Z|I|J]|$G|10|H|11|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|F|7|13|8|@]|9|@]|A|$]]|$1|O|3|-4|5|F|7|14|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>char sep = '\n' /1\
; int i = 68 /1 \
; while (i --- 1\
 \
 /1/1/1 /1\
 /1\
 /1\
 /1\
 /1\
 / 1\
 / 1 \
 / 1 \
 / 1 \
 /1 /1 \
 /1 /1 \
 /1 /1 /1/1&gt; 0) std::cout \
 &lt;&lt;i&lt;&lt; sep;
</code></pre>
For larger numbers, C++20 introduces some more advanced looping features.
First to catch <code>i</code> we can build an inverse loop-de-loop and deflect it onto the <code>std::ostream</code>. However, the speed of <code>i</code> is implementation-defined, so we can use the new C++20 speed operator <code>&lt;&lt;i&lt;&lt;</code> to speed it up. We must also catch it by building wall, if we don't, <code>i</code> leaves the scope and de referencing it causes undefined behavior. To specify the separator, we can use:
<pre><code> std::cout \
 sep
</code></pre>
and there we have a for loop from 67 to 1.

blocks|key|1421404|text|除了常规的箭头操作符(-->)，您可以使用穿甲箭头操作符：--x>+(注意箭头尖端上的那些尖锐的倒钩)。它在穿甲上增加了%2B1，因此它比普通箭头操作符更快地完成循环1迭代。你自己试试吧：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1421405|int+x+=+10;
while(+--x>+0+)
++++printf("%25d+",+x);|code-block|syntax|javascript|1421406|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|$]]

Instead of regular arrow operator (--&gt;) you can use armor-piercing arrow operator: --x&gt; (note those sharp barbs on the arrow tip). It adds +1 to armor piercing, so it finishes the loop 1 iteration faster than regular arrow operator. Try it yourself:
<pre><code>int x = 10;
while( --x&gt; 0 )
 printf(&quot;%d &quot;, x);
</code></pre>

blocks|key|1206365|text|实际上，您可以只是为了好玩而“创建”一个-->运算符)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1206366|class+MyClass+{
++++class+Helper
++++{
++++++++MyClass*+ptr;
++++++++Helper(MyClass*+_this):+ptr{_this}+{}
++++public:
++++++++Helper(const+Helper&)+=+delete;
++++++++Helper(Helper&&)+=+delete;
++++++++void+operator=(const+Helper&)+=+delete;
++++++++void+operator=(Helper&&)+=+delete;
++++++++operator+MyClass()
++++++++{
++++++++++++auto+tmp+=+*ptr;
++++++++++++tmp._value%2B%2B;
++++++++++++return+tmp;
++++++++}
++++++++friend+MyClass;
++++++++void+operator>(int){std::cout+<<+"Operator+-->"+<<+std::endl;}
++++};

++++int+_value+=+0;
public:
++++MyClass()+=+default;
++++MyClass(int+value):+_value{value}+{}
++++Helper+operator--(int)
++++{
++++++++_value--;
++++++++return+Helper(this);
++++}
++++int+get()+const+noexcept
++++{
++++++++return+_value;
++++}
++++bool+operator>(int+num)+const+noexcept
++++{
++++++++return+_value+>+num;+
++++}
};

int+main()
{
++++MyClass+obj(5);
++++obj+>+1;++++++++++++//operator+>
++++obj--;++++++++++++++//operator+--
++++MyClass+b+=+obj--;++//still+works
++++std::cout+<<+b.get()+<<+std::endl;++++++//4
++++std::cout+<<+obj.get()+<<+std::endl;++++//3
++++b+-->+5;++++++++++++//operator+-->
++++//But+there+is+at+least+one+problem
++++auto+c+=+obj--;+++++//auto+can+deduce+a+private+type+:(
}|code-block|syntax|javascript|1206367|但正如我所说的，它只是为了好玩;)|1206368|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|$]]

Actually, you can &quot;create&quot; a --&gt; operator just for fun )
<pre><code>class MyClass {
 class Helper
 {
 MyClass* ptr;
 Helper(MyClass* _this): ptr{_this} {}
 public:
 Helper(const Helper&amp;) = delete;
 Helper(Helper&amp;&amp;) = delete;
 void operator=(const Helper&amp;) = delete;
 void operator=(Helper&amp;&amp;) = delete;
 operator MyClass()
 {
 auto tmp = *ptr;
 tmp._value++;
 return tmp;
 }
 friend MyClass;
 void operator&gt;(int){std::cout &lt;&lt; &quot;Operator --&gt;&quot; &lt;&lt; std::endl;}
 };

 int _value = 0;
public:
 MyClass() = default;
 MyClass(int value): _value{value} {}
 Helper operator--(int)
 {
 _value--;
 return Helper(this);
 }
 int get() const noexcept
 {
 return _value;
 }
 bool operator&gt;(int num) const noexcept
 {
 return _value &gt; num; 
 }
};

int main()
{
 MyClass obj(5);
 obj &gt; 1; //operator &gt;
 obj--; //operator --
 MyClass b = obj--; //still works
 std::cout &lt;&lt; b.get() &lt;&lt; std::endl; //4
 std::cout &lt;&lt; obj.get() &lt;&lt; std::endl; //3
 b --&gt; 5; //operator --&gt;
 //But there is at least one problem
 auto c = obj--; //auto can deduce a private type :(
}
</code></pre>
But as I said it's only for fun ;)

After reading <a href="http://groups.google.com/group/comp.lang.c++.moderated/msg/33f173780d58dd20" rel="noreferrer">Hidden Features and Dark Corners of C++/STL</a> on <code>comp.lang.c++.moderated</code>, I was completely surprised that the following snippet compiled and worked in both Visual Studio 2008 and G++ 4.4.
Here's the code:
<pre><code>#include &lt;stdio.h&gt;
int main()
{
 int x = 10;
 while (x --&gt; 0) // x goes to 0
 {
 printf(&quot;%d &quot;, x);
 }
}
</code></pre>
Output:
<pre><code>9 8 7 6 5 4 3 2 1 0
</code></pre>
I'd assume this is C, since it works in GCC as well. Where is this defined in the standard, and where has it come from?

What is the "-->" operator in C/C++?

Visual Studio

编译器

在阅读了comp.lang.c++.moderated上的后，我完全惊讶地发现以下代码片段在Visual Studio2008和G++ 4.4中都可以编译和工作。代码如下：#include <stdio.h>int main(){ int x = 10; while (x --> 0) // x goes ...

问C/C++中的"-->“运算符是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C/C++中的"-->“运算符是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C/C++中的"-->“运算符是什么？
EN