C++ 中的“-->”运算符是什么？
[英]What is the "-->" operator in C++?
问题描述
在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 个解决方案
解决方案1
9477 已采纳
-->不是运算符。 它实际上是两个独立的运算符--和> 。
条件代码递减x ，同时返回x的原始（未递减）值，然后使用>运算符将原始值与0进行比较。
为了更好地理解，该语句可以写成如下：
while( (x--) > 0 )
解决方案2
3704
或者对于完全不同的东西...... x滑动到0 。
while (x --\
\
\
\
> 0)
printf("%d ", x);
不是那么数学，但是...每张图片都描绘了一千个单词...
解决方案3
2539
这是一个非常复杂的运算符，因此甚至ISO/IEC JTC1（联合技术委员会 1）也将其描述放在 C++ 标准的两个不同部分中。
开个玩笑，它们是两个不同的运算符： --和>分别在 C++03 标准的 §5.2.6/2 和 §5.9 中描述。
解决方案4
1622
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
;)
解决方案5
1406
相当于
while (x-- > 0)
x-- (post decrement) 等价于x = x-1因此，代码转换为：
while(x > 0) {
x = x-1;
// logic
}
x--; // The post decrement done when x <= 0
解决方案6
596
它是
#include <stdio.h>
int main(void) {
int x = 10;
while (x-- > 0) { // x goes to 0
printf("%d ", x);
}
return 0;
}
只是空间让事情看起来很有趣， --递减和>比较。
解决方案7
476
-->的用法具有历史意义。 在 x86 架构上，递减曾经（并且在某些情况下仍然如此）比递增快。 使用-->表明x将变为0 ，并吸引具有数学背景的人。
解决方案8
419
完全是极客，但我将使用这个：
#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;
}
解决方案9
403
while( x-- > 0 )
是如何解析的。
解决方案10
353
我读过的一本书（我不记得是哪本书了）说：编译器尝试使用左右规则将表达式解析为最大的标记。
在这种情况下，表达式：
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
解决方案11
293
这与
while (x--)
解决方案12
259
无论如何，我们现在有一个“去”操作员。 "-->"作为一个方向很容易被记住，而“当x变为零时”是直截了当的意思。
此外，在某些平台上，它比"for (x = 10; x > 0; x --)"更有效。
解决方案13
235
此代码首先比较 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
解决方案14
193
当我运行此代码时，我的编译器将打印出 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”。
解决方案15
161
--和>之间缺少一个空格。 x后递减，即检查条件x>0 ? .
解决方案16
149
--是递减运算符， >是大于运算符。
这两个运算符作为一个单独的运算符应用--> 。
解决方案17
141
它是两个运算符的组合。 首先--用于递减值， >用于检查值是否大于右侧操作数。
#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
解决方案18
138
C 和 C++ 遵循“最大咀嚼”规则。 与a---b转换为(a--) - b的方式相同，在您的情况下x-->0转换为(x--)>0 。
该规则本质上说的是，从左到右，表达式是通过获取将形成有效标记的最大字符来形成的。
解决方案19
131
实际上， x是后递减的，并且正在检查该条件。 不是--> ，而是(x--) > 0
注意： x的值在条件检查后会更改，因为它是在递减后。 一些类似的情况也可能发生，例如：
--> x-->0
++> x++>0
-->= x-->=0
++>= x++>=0
解决方案20
32
为什么所有的并发症？
原始问题的简单答案是：
#include <stdio.h>
int main()
{
int x = 10;
while (x > 0)
{
printf("%d ", x);
x = x-1;
}
}
它做同样的事情。 我并不是说你应该这样做，但它会做同样的事情，并且会在一篇文章中回答这个问题。
x--只是上面的简写，而>只是一个普通的大于operator 。 没有什么大谜团！
现在有太多人把简单的事情复杂化了；）
解决方案21
32
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 循环。
解决方案22
30
我们在 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
}
}
两种方式，我们做同样的事情，实现同样的目标。
解决方案23
25
(x --> 0)表示(x-- > 0) 。
- 您可以使用
(x -->)
Output: 9 8 7 6 5 4 3 2 1 0
- 你可以使用
(-- x > 0)这意味着(--x > 0)
Output: 9 8 7 6 5 4 3 2 1
- 您可以使用
(--\
\
x > 0)
Output: 9 8 7 6 5 4 3 2 1
- 您可以使用
(\
\
x --> 0)
Output: 9 8 7 6 5 4 3 2 1 0
- 您可以使用
(\
\
x --> 0
\
\
)
Output: 9 8 7 6 5 4 3 2 1 0
- 你也可以使用
(
x
-->
0
)
Output: 9 8 7 6 5 4 3 2 1 0
同样，您可以尝试很多方法来成功执行此命令。
解决方案24
24
您可以使用穿甲箭头操作符来代替常规的箭头操作符 (-->)：--x> （注意箭头尖端的那些锋利的倒钩）。 它为穿甲增加了 +1，因此它比常规箭头运算符更快地完成循环 1 迭代。 自己试试：
int x = 10;
while( --x> 0 )
printf("%d ", x);
解决方案25
4
这-->根本不是一个运算符。 我们有一个类似->的运算符，但不像--> 。 这只是对while(x-- >0)的错误解释，这仅意味着 x 具有后减量运算符，并且此循环将运行直到它大于零。
编写此代码的另一种简单方法是while(x--) 。 当while循环遇到错误条件时将停止，这里只有一种情况，即0 。 因此，当 x 值减为零时，它将停止。
解决方案26
3
这里--是一元后减运算符。
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循环退出。
解决方案27
3
-->不是运算符，它是-- （后减）和> （大于比较）的并置。
循环看起来更熟悉：
#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# 等等。
解决方案28
2
实际上，您可以“创建”一个 --> 运算符只是为了好玩）
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 :(
}
但正如我所说，这只是为了好玩；)
解决方案29
0
这就是你的意思。
while((x--) > 0)
小时候听过，
停止不要，放手 (روکو مت، جانے دو)
逗号使人混淆的地方
停下，别放手。 (روکو، مت جانے دو)
现在编程中也会发生同样的情况，SPACE 会造成混乱。 :D
解决方案30
0
运算符是对变量和值执行操作的符号。 例如，+ 是用于加法的运算符，而 - 是用于减法的运算符。
--> 它不是一个运算符，实际上它们是两个不同的运算符 -- 或 >。
C++中的运算符可分为6种
Arithmetic Operators | +, -, *, /, %
Assignment Operators | =, +=, -=, *=, /=, %=
Relational Operators | ==, !=, >, <, >=, <=
Logical Operators | &&, ||, !
Bitwise Operators | &, |, ^, ~, <<, >>
Other Operators | sizeof, ?:, &, ., ->, <<, >>
解决方案31
-2
在2个运算符之间放置一个空格，否则编译器会将其视为单个运算符。 （z--> 0）
解决方案32
-2
它实际上是后缀操作
while(x-- > 0)
什么是C ++中的 - > *运算符？
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.