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

Question

看完后隐藏功能和C++/STL的暗角上comp.lang.c++.moderated,我完全惊讶的是,下面的代码片断编译并在两个Visual Studio 2008和G ++ 4.4的工作.

这是代码:

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

我假设这是C,因为它也适用于GCC.标准中定义了哪里,它来自何处？

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++标准的两个不同部分.

开玩笑一边,它们是两个不同的运营商:--和>分别在§5.2.6/ 2和C++ 03标准的§5.9中描述.

Answer 4

它相当于

while (x-- > 0)

x--(post decrement)相当于x = x-1,代码转换为:

while(x > 0) {
    x = x-1;
    // logic
}

Answer 5

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 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

while( x-- > 0 )

是如何解析的.

Answer 9

非常极客,但我将使用这个:

#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 10

我读过的一本书(我不记得哪本书正确)说明:编译器尝试使用左右规则将表达式解析为最大的标记.

在这种情况下,表达式:

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 11

这完全一样

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

对于非负数

Answer 12

无论如何,我们现在有一个"去"操作员."-->"很容易被人们记住作为一个方向,而"当x变为零"意味着直接.

此外,它比"for (x = 10; x > 0; x --)"某些平台更有效.

Answer 13

此代码首先比较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 14

运行此代码时,我的编译器将打印出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 15

--和之间缺少空间>.x后递减,即在检查条件后递减x>0 ?.

Answer 16

--是递减运算符,>是大于运算符.

两个运算符作为单个运算符应用-->.

Answer 17

它是两个运营商的组合.第--一个用于递减值,>用于检查该值是否大于右侧操作数.

#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 18

实际上,x是后递减,并且正在检查该条件.它不是-->,它是(x--) > 0

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

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

Answer 19

C和C++遵守"最大蒙克"规则.a --- b被翻译成同样的方式(a--) - b,在你的情况下 x-->0翻译成(x--)>0.

规则本质上是从左到右,表达式是通过获取将形成有效表达式的最大字符来形成的.

Answer 20

为什么所有的并发症？

原始问题的简单答案就是:

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

做同样的事情.不是说你应该这样做,但它做了同样的事情,并且会在一篇文章中回答这个问题.

这x--只是上述的简写,>只是一个正常的大于operator.没什么大不了的!

现在有太多的人把简单的事情弄复杂了;)

Answer 21

传统的方式我们定义的条件,而循环括号" while'和终止条件的括号内’ ()",但这{}与-->一个办法一个定义的一次.例如:

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

它说,减少a并运行循环直到时间a大于0

其他方式应该是这样的:

int abc(void)
{
    int a = 5;
    while(a > 0)
    {
        a--;
        // Code
    }
    a--;
}

两种方式,我们做同样的事情,实现相同的目标.

Answer 22

(x --> 0)是指(x-- > 0)。

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

2. 你可以用(-- x > 0) 它的意思(--x > 0)
Output: 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 23

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;

对于更大的数字，C++20 引入了一些更高级的循环功能。首先，i我们可以构建一个反向循环去循环并将其偏转到std::ostream. 但是，速度i是实现定义的，因此我们可以使用新的 C++20 速度运算符<<i<<来加快速度。我们还必须通过构建 wall 来捕捉它，如果我们不这样做，i就会离开作用域并取消引用它会导致未定义的行为。要指定分隔符，我们可以使用：

 std::cout \
           sep

我们有一个从 67 到 1 的 for 循环。

Answer 24

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

该循环看起来会更熟悉：

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

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

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

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

另请注意，如果具有无符号类型（例如 ） ，则此循环将以相同的方式运行，这比简单的替代方案具有很大的优势。xsize_tfor (i = length-1; i >= 0; i--)

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

Answer 25

您可以使用穿甲箭头运算符来代替常规箭头运算符 (-->)：--x>（注意箭头尖端上的那些尖锐倒钩）。它为穿甲加 1，因此它比常规箭头运算符更快地完成循环 1 迭代。自己试试：

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

Answer 26

这-->根本就不是一个运营商。我们有一个运算符 like ->，但没​​有 like -->。这只是一个错误的解释，while(x-- >0)它仅仅意味着 x 具有后减运算符，并且该循环将运行直到它大于零。

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

Answer 27

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

 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循环退出。