繁体   English   中英

C++ 中的“-->”运算符是什么?

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

提示:本站收集StackOverFlow近2千万问答,支持中英文搜索,鼠标放在语句上弹窗显示对应的参考中文或英文, 本站还提供   中文繁体   英文版本   中英对照 版本,有任何建议请联系yoyou2525@163.com。

comp.lang.c++.moderated上阅读C++/STL 的隐藏功能和暗角后,我完全惊讶于以下代码片段在 Visual Studio 2008 和 G++ 4.4 中编译和工作。

这是代码:

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

Output:

9 8 7 6 5 4 3 2 1 0

我假设这是 C,因为它也适用于 GCC。 这在标准中是哪里定义的,它是从哪里来的?

29 个回复

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

条件代码递减x ,同时返回x的原始(未递减)值,然后使用>运算符将原始值与0进行比较。

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

while( (x--) > 0 )

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

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

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

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

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

x可以在 C++ 中以相反的方向更快地归零:

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

;)

相当于

while (x-- > 0)

x-- (post decrement) 等价于x = x-1因此,代码转换为:

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

它是

#include <stdio.h>

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

只是空间让事情看起来很有趣, --递减和>比较。

-->的用法具有历史意义。 在 x86 架构上,递减曾经(并且在某些情况下仍然如此)比递增快。 使用-->表明x将变为0 ,并吸引具有数学背景的人。

完全是极客,但我将使用这个:

#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;
}
while( x-- > 0 )

是如何解析的。

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

在这种情况下,表达式:

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

这与

while (x--)

无论如何,我们现在有一个“去”操作员。 "-->"作为一个方向很容易被记住,而“当x变为零时”是直截了当的意思。

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

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

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

-->之间缺少一个空格。 x后递减,即检查条件x>0 ? .

--递减运算符, >大于运算符。

这两个运算符作为一个单独的运算符应用-->

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

#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            

C 和 C++ 遵循“最大咀嚼”规则。 a---b转换为(a--) - b的方式相同,在您的情况下x-->0转换为(x--)>0

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

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

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

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

为什么所有的并发症?

原始问题的简单答案是:

#include <stdio.h>

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

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

x--只是上面的简写,而>只是一个普通的大于operator 没有什么大谜团!

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

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<<来加速它。 我们还必须通过构建墙来捕获它,如果我们不这样做, i会离开范围并取消引用它会导致未定义的行为。 要指定分隔符,我们可以使用:

 std::cout \
           sep

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

我们在 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
    }
}

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

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

  1. 您可以使用(x -->)
    Output: 9 8 7 6 5 4 3 2 1 0
  1. 你可以使用(-- x > 0)这意味着(--x > 0)
    Output: 9 8 7 6 5 4 3 2 1
  1. 您可以使用
(--\
    \
     x > 0)

Output: 9 8 7 6 5 4 3 2 1

  1. 您可以使用
(\
  \
   x --> 0)

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

  1. 您可以使用
(\
  \
   x --> 0
          \
           \
            )

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

  1. 你也可以使用
(
 x 
  --> 
      0
       )

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

同样,您可以尝试很多方法来成功执行此命令。

您可以使用穿甲箭头操作符来代替常规的箭头操作符 (-->):--x> (注意箭头尖端的那些锋利的倒钩)。 它为穿甲增加了 +1,因此它比常规箭头运算符更快地完成循环 1 迭代。 自己试试:

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

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

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

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

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

-->不是运算符,它是-- (后减)和> (大于比较)的并置。

循环看起来更熟悉:

#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之类的无符号类型,则此循环将以相同的方式运行,这比for (i = length-1; i >= 0; i--)的幼稚替代方案具有很大优势。

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

实际上,您可以“创建”一个 --> 运算符只是为了好玩)

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++;
            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 :(
}

但正如我所说,这只是为了好玩;)

这就是你的意思。

while((x--) > 0)

小时候听过,

停止不要,放手 (روکو مت، جانے دو)

逗号使人混淆的地方

停下,别放手。 (روکو، مت جانے دو)

现在编程中也会发生同样的情况,SPACE 会造成混乱。 :D

运算符是对变量和值执行操作的符号。 例如,+ 是用于加法的运算符,而 - 是用于减法的运算符。

--> 它不是一个运算符,实际上它们是两个不同的运算符 -- 或 >。

C++中的运算符可分为6种

Arithmetic Operators | +, -, *, /, %
Assignment Operators | =, +=, -=, *=, /=, %=
Relational Operators | ==, !=, >, <, >=, <=
Logical Operators    | &&, ||, !
Bitwise Operators    | &, |, ^, ~, <<, >>
Other Operators      | sizeof, ?:, &, ., ->, <<, >>

在2个运算符之间放置一个空格,否则编译器会将其视为单个运算符。 (z--> 0)

它实际上是后缀操作

while(x-- > 0)
2 什么是C ++中的<<运算符?

我来自C#和Java背景到C ++,我试图理解&gt;&gt; & &lt;&lt;运算符,如in 我在这里无法理解的是&lt;&lt;运算符是为了什么。 我尝试声明我自己的简单函数,它总是返回整数5 ,我可以像在C#中那样调用它, 并且将x变为5 ,但为什么我需要使用std: ...

3 什么是C ++中的operator << <>?

我在几个地方看过这个,为了证实我并不疯狂,我寻找其他的例子 。 显然,这也可以有其他风格,例如operator+ &lt;&gt; 。 然而,我在任何地方都没有看到它是什么,所以我想我会问。 谷歌operator&lt;&lt; &lt;&gt;( :-)并不是最简单的事情 ...

4 C ++中的运算符“”是什么?

我落在这个页面上,作者谈到了运营商“”的标准化 : C ++标准委员会决定标准化operator ""是[...] 他/她在说什么? 我找不到任何关于这个的信息,我不明白它可能意味着什么(对于常量字符串重载?或者更概念性的东西,这不会影响语言的最终用法?) ...

5 什么是C ++中的<< =运算符

我在遗留系统中找到了以下代码。由于这似乎是“赋值和左移”,但我看到此代码将字符串复制到ws,但我不明白该怎么做? 我不知道简单的赋值是否足以将一个字符串复制到另一个字符串,那么为什么有人会这样编码? 编辑-我查看了类的实现(c:\\ Program Files(x86)\\ Micro ...

7 什么是在c ++中调用的()运算符?

什么是()运算符调用? 它是否使用new运算符创建对象? 我尝试在谷歌搜索,但结果中没有“()”,即使有引号。 编辑:( ()通常与仿函数一起使用,但它可以用于没有重载operator () 。 它创建了类的对象。 ...

8 什么是C ++中的<?=运算符[重复]

可能重复: &gt;?=运算符是什么意思? 我想知道在C ++代码中我一直看到的&lt;?=运算符是什么。 它不能在我的系统上编译,但我确定它是正确的。 它的使用方式如下: a &lt;?= something; 另外,我需要做些什么才能编译它? 编辑后: ...

9 什么是C ++中的重载运算符?

我意识到这是一个基本的问题,但我已经在网上搜索过,去了cplusplus.com,通读了我的书,我似乎无法掌握重载运算符的概念。 cplusplus.com的一个具体示例是: 从http://www.cplusplus.com/doc/tutorial/classes2/,但阅读它我仍 ...

10 这个C ++运算子是什么意思?

我对C ++一无所知,我需要将一些代码更改为其他编程语言。 有人可以告诉我以下代码是什么意思吗? 具体来说, . / . /我不清楚。 ...

2016-01-15 16:26:08 2 105   c++
暂无
暂无

声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2022 STACKOOM.COM