什么是'-->' C/C++ 中的运算符？

Question

阅读C++/STL 的隐藏功能和黑暗角落后在 comp.lang.c++.moderated 上，我完全惊讶于以下代码片段在 Visual Studio 2008 和 G++ 4.4 中都能编译并运行。我认为这也是有效的 C，因为它也适用于 GCC。

代码如下：

#include <stdio.h>
int main()
{
    int x = 10;
    while (x --> 0) // x goes to 0
    {
        printf("%d ", x);
    }
}

输出：

9 8 7 6 5 4 3 2 1 0

标准中在哪里定义了它，它来自哪里？

Answer 1

--> 不是运算符。它实际上是两个独立的运算符，-- 和>。

条件中的代码递减 x，同时返回 x 的原始（未递减）值，然后使用以下命令将原始值与 0 进行比较> 运算符。

为了更好地理解，该语句可以写成如下：

while( (x--) > 0 )

Answer 2

或者对于完全不同的东西...x 滑动到0。

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

不是那么数学化，但是...每张图片都描绘了一千个单词...

Answer 3

这是一个非常复杂的运算符，因此甚至 ISO/IEC JTC1（联合技术委员会 1） 也放置了其描述在 C++ 标准的两个不同部分中。

开玩笑吧，它们是两个不同的运算符：-- 和 > 分别在 C++03 标准的 §5.2.6/2 和 §5.9 中描述。

Answer 4

在 C++ 中，x 可以在相反方向更快地变为零：

int x = 10;

while( 0 <---- x )
{
   printf("%d ", x);
}

8 6 4 2

您可以用箭头控制速度！

int x = 100;

while( 0 <-------------------- x )
{
   printf("%d ", x);
}

90 80 70 60 50 40 30 20 10

Answer 5

它相当于

while (x-- > 0)

x--（后递减）相当于x = x-1（但返回x的原始值），所以代码转换为：

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

Answer 6

只是

#include <stdio.h>

int main(void) {
    int x = 10;
    while (x-- > 0) { // x goes to 0
        printf("%d ", x);
    }
    return 0;
}

空格让事情看起来很有趣，-- 递减和> 比较。

Answer 7

--> 的使用具有历史相关性。在 x86 架构上，递减曾经（并且在某些情况下仍然如此）比递增更快。使用 --> 表明 x 将变为 0，并且对具有数学背景的人很有吸引力。

Answer 8

非常极客，但我将使用这个：

#define as ;while

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

Answer 9

我读过的一本书（我不记得是哪本书了）指出：编译器尝试使用左右规则将表达式解析为最大的标记。

在这种情况下，表达式：

x-->0

解析为最大标记：

token 1: x
token 2: --
token 3: >
token 4: 0
conclude: x-- > 0

相同的规则适用于此表达式：

a-----b

解析后：

token 1: a
token 2: --
token 3: --
token 4: -
token 5: b
conclude: (a--)-- - b

Answer 10

这与非负数的 while(x--) 完全相同。

Answer 11

不管怎样，我们现在有了一个“gos to”操作符。 “-->”作为方向很容易被记住，而“当x变为零”的意思是直线。

此外，在某些平台上，它比 “for (x = 10; x > 0; x --)” 更高效。

Answer 12

该代码首先比较 x 和 0，然后递减 x。 （在第一个答案中也说过：您要对 x 进行后递减，然后使用 > 运算符比较 x 和 0。）请参阅此代码的输出：

9 8 7 6 5 4 3 2 1 0

我们现在首先比较，然后递减在输出中看到 0。

如果我们想先递减然后比较，请使用以下代码：

#include <stdio.h>
int main(void)
{
    int x = 10;

    while( --x> 0 ) // x goes to 0
    {
        printf("%d ", x);
    }
    return 0;
}

输出为：

9 8 7 6 5 4 3 2 1

Answer 13

当我运行此代码时，我的编译器将打印出 9876543210。

#include <iostream>
int main()
{
    int x = 10;

    while( x --> 0 ) // x goes to 0
    {
        std::cout << x;
    }
}

正如预期的那样。 while( x-- > 0 ) 实际上意味着 while( x > 0)。 x-- 后递减 x。

while( x > 0 ) 
{
    x--;
    std::cout << x;
}

是同一件事的不同写法。

很高兴原来的看起来像“当 x 变为 0”。

Answer 14

-- 和 > 之间缺少空格。 x 是后递减的，即在检查条件 x>0 ? 后递减。

Answer 15

-- 是减量 运算符，> 是大于 运算符。

这两个运算符作为一个运算符应用，如 -->。

Answer 16

它是两个运算符的组合。第一个 -- 用于递减值，> 用于检查值是否大于右侧操作数。

#include<stdio.h>

int main()
{
    int x = 10;

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

    return 0;
}

输出将是：

9 8 7 6 5 4 3 2 1 0            

Answer 17

C 和 C++ 遵循“最大咀嚼”规则。同样的方式将 a---b 翻译为 (a--) - b，在您的情况下 x-->0 会翻译到(x--)>0。

该规则本质上说的是，从左到右，表达式是通过采用将形成有效标记的最大字符来形成的。

Answer 18

实际上，x 是后递减的，并且正在检查该条件。这不是 -->，而是 (x--) > 0

注意：x 的值在检查条件后会更改，因为它是后递减的。一些类似的情况也可能发生，例如：

-->    x-->0
++>    x++>0
-->=   x-->=0
++>=   x++>=0

Answer 19

您可以使用穿甲箭头运算符来代替常规箭头运算符（-->）：--x> （注意箭头尖端上的那些锋利的倒刺）。它为穿甲增加 +1，因此它比常规箭头操作员更快地完成循环 1 迭代。自己尝试一下：

int x = 10;
while( --x> 0 )
    printf("%d ", x);

Answer 20

对原始问题的简单回答是，以下代码执行相同的操作（尽管我并不是说您应该这样做）：

#include <stdio.h>

int main() {
    int x = 10;
    while (x > 0) {
        printf("%d ", x);
        x = x - 1;
    }
}

x-- 只是上面的简写，而 < code>> 只是一个普通的大于运算符。

Answer 21

(x --> 0) 表示 (x-- > 0)。

1. 您可以使用(x -->)
输出：9 8 7 6 5 4 3 2 1 0

2. 你可以使用 (-- x > 0) 意思是 (--x > 0)
输出：9 8 7 6 5 4 3 2 1

3. 您可以使用

(--\
    \
     x > 0)

Output: 9 8 7 6 5 4 3 2 1

4. 您可以使用

(\
  \
   x --> 0)

Output: 9 8 7 6 5 4 3 2 1 0

5. 您可以使用

(\
  \
   x --> 0
          \
           \
            )

Output : 9 8 7 6 5 4 3 2 1 0

6. 你也可以使用

(
 x 
  --> 
      0
       )

Output: 9 8 7 6 5 4 3 2 1 0

同样，你可以尝试很多方法来执行这个命令成功地。

Answer 22

常规方式我们在 while 循环括号“()”中定义条件，在大括号“{}”内定义终止条件，但是这个 -- & ; > 是一种一次性定义所有内容的方式。
例如：

int abc(){
    int a = 5
    while((a--) > 0){ // Decrement and comparison both at once
        // Code
    }
}

它说，递减 a 并运行循环，直到 a 大于 0

其他方式应该是这样的：

int abc() {
    int a = 5;
    while(a > 0) {
        a = a -1 // Decrement inside loop
        // Code
    }
}

两者方式，我们做同样的事情，实现同样的目标。

Answer 23

--> 不是运算符，它是 --（后自减）和 >（大于比较）的并置。

该循环看起来更熟悉：

#include <stdio.h>
int main() {
    int x = 10;
    while (x-- > 0) { // x goes to 0
        printf("%d ", x);
    }
}

此循环是一个经典的习惯用法，用于枚举 10 （排除的上限）和 0 包含的下限之间的值，对于迭代非常有用数组中从最后一个到第一个的元素。

初始值10是迭代总数（例如数组的长度），加上循环内使用的第一个值。 0 是循环内 x 的最后一个值，因此注释 x 变为 0。

请注意，循环完成后x 的值为-1。

另请注意，如果 x 具有无符号类型（例如 size_t），则此循环将以相同方式运行，即与 (i = length-1; i >= 0; i--) 的朴素替代方案相比，这是一个强大的优势。

出于这个原因，我实际上很喜欢这种令人惊讶的语法：while (x --> 0)。我发现这个习语引人注目且优雅，就像 for (;;) 与： while (1) （看起来与 while (l) 令人困惑） ）。它也适用于语法受 C 启发的其他语言：C++、Objective-C、java、javascript、C# 等等。

Answer 24

这里 -- 是一元后减运算符。

 while (x-- > 0) // x goes to 0
 {
     printf("%d ", x);
 }

• 一开始，条件将评估为
  (x > 0) // 10 > 0
• 现在因为条件为真，它将进​​入循环并减少值
  x-- // x = 9
• 这就是为什么第一个打印的值为 9
• 等等。在最后一个循环中x=1，所以条件为真。根据一元运算符，该值在打印时更改为 x = 0。
• 现在，x = 0，它将条件 (x > 0 ) 计算为 false，并且 while 循环退出。

Answer 25

这个 --> 根本不是一个运算符。我们有一个类似于 -> 的运算符，但不像 --> 那样。这只是 while(x-- >0) 的错误解释，它只是意味着 x 具有后递减运算符，并且此循环将运行直到它大于零 。

编写此代码的另一种简单方法是 while(x--)。 while循环只要遇到错误条件就会停止，这里只有一种情况，即0。因此，当 x 值减至零时，它将停止。

Answer 26

这就是你的意思。

while((x--) > 0)

我们小时候就听过，

别停下来，放手(Road Go)

?????????????????????????????????????????????????????????????????????????????????????????????????????????

停下来，别放手。

发生同样的情况，空格会造成混乱。 ：D