在阅读了C++/STL的C++/STL的隐藏特征和暗角(comp.lang.c++.modated)之后,我感到非常惊讶的是,以下的片段在2008年视觉工作室和G++4.4编辑和工作。
代码如下:
#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
我想这是C,因为它在海合会也是工作。标准中的定义在哪里,它来自何处?
- >不是一个操作员。它实际上是两个单独的操作员,--和 >。
条件值的代码缩进 x, 同时返回 x 的原始值( 未降值 ) , 然后使用 > 运算符将原始值与 0 比较 。
为了更好地了解,声明可以写成如下:
while( (x--) > 0 )
相当于
while (x-- > 0)
x- (后衰减) 等于 x = x-1 (但返回X 的原值) , 所以代码转换为 :
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;
}
空间让事情变得有趣 -- -- 降级和 > 比较。
这是一个非常复杂的操作员,所以甚至ISO/IEC JTC1(联合技术委员会1)也将其描述置于C++标准的两个不同部分。
除此以外,它们是两个不同的操作者: -- -- 和 > 分别在C+/03标准§5.2.6/2和§5.9中说明。
总之,我们现在有一个"去"接线员。 " - - >"很容易被记住是一个方向, 而"当x去到零"的意思是直截了当的。
此外,它比某些平台上的“(x=10; x > 0; x-)”效率略高一些。
-- > 的用法具有历史意义。 衰落曾经( 在某些情况下现在仍然是) 比x86 结构的递增速度快。 使用 -- > 表示x 将达到 0, 并且吸引有数学背景的人 。
此代码首先比较 x 和 0 , 然后比较 。 (第一个答案中也这么说 : 您是 后降 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;
}
}
如预期的那样。当值( x - - > 0) 实际意味着当值( x > 0 ) 。 x - 后天缩减 x 。
while( x > 0 )
{
x--;
std::cout << x;
}
是一个不同的写法 相同的东西。
原版看起来像"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
丑陋的怪胎, 但我会使用这个:
#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;
}
或者是完全不同的东西... x 幻灯片到 0 。
while (x --\
\
\
\
> 0)
printf("%d ", x);
不那么数学,但是... 每幅画画上写着一千个字...
实际上, 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);
return 0;
}
产出将是:
9 8 7 6 5 4 3 2 1 0
C++ 和 C++ 遵守“ 最大食量” 规则。 与 a- b 被翻译为 (a-) - b 的方式相同, 在您的情况下 x - > 0 被翻译为 (x-) > 0 。
规则的基本内容是左向右, 表达式通过使用最大字符组成, 从而形成一个有效的符号 。
x 可以在 C++ 的相反方向更快地达到零:
int x = 10;
while( 0 <---- x )
{
printf("%d ", x);
}
8 8 6 4 2
你可以用箭来控制速度!
int x = 100;
while( 0 <-------------------- x )
{
printf("%d ", x);
}
90 90 80 70 60 50 40 30 10
; ; ;)
为什么这么复杂?
对最初问题的简单答案是:
#include <stdio.h>
int main()
{
int x = 10;
while (x > 0)
{
printf("%d ", x);
x = x-1;
}
}
我并不是说你们应该这样做,但是它也这样做,而且会用一个文章回答问题。
X -只是上面的简称, 和 > 只是一个正常的比操作员更大的操作员。 没有大谜!
) 太多人让简单的事情变得复杂,
我们用常规的方式定义状态, 而循环括号“ () ) ” 和牙套“\\\\\\\\\\\\\\\\\\\ ” 中的终止状态, 但是-- & > 是一个同时定义所有状态的方法。 例如 :
int abc(){
int a = 5
while((a--) > 0){ // Decrement and comparison both at once
// Code
}
}
上面写着, 降一个, 并运行回环, 直到时间 a 大于 0 。
换句话说,它本该是这样的:
int abc() {
int a = 5;
while(a > 0) {
a = a -1 // Decrement inside loop
// Code
}
}
无论是哪种方式,我们都做同样的事情,实现同样的目标。
( -- > 0) 系指 (x - - > 0) 。
您可以使用 (x -- >) 输出: 9 8 7 7 6 5 4 4 3 2 1 0
输出: 9 8 7 7 6 5 5 4 3 2 1
您可以使用
(--\
\
x > 0)
产出: 9 8 8 7 7 6 5 4 4 3 2 1
您可以使用
(\
\
x --> 0)
产出: 9 8 8 7 7 6 5 4 4 3 2 1 0
您可以使用
(\
\
x --> 0
\
\
)
产出: 9 8 8 7 7 6 5 4 4 3 2 1 0
您也可以使用
(
x
-->
0
)
产出: 9 8 8 7 7 6 5 4 4 3 2 1 0
同样,您也可以尝试很多方法来成功执行此命令 。
这个 -- > 根本不是一个操作员。 我们有一个类似 -- > 的操作员, 但不像 -- > 。 这只是对时间( x - - - > 0) 的错误解释, 仅仅表示 x 有后衰落操作员, 而这个循环会运行到它大于零 。
写这个代码的另一种简单方式是时间( x - - ) 。 当它出现虚假状况时, 循环就会停止, 这里只有一个案例, 即 0 。 所以当 x 值降为零时它就会停止 。
这里 -- -- 是一个纯净的后衰减操作员。
while (x-- > 0) // x goes to 0
{
printf("%d ", x);
}
开始时, 条件会以 (x > 0) / / / 10 > 0 来评价 (x > 0) / / 10 > 0 。 现在, 因为条件是真实的, 它会以衰减值 x - / x = 9 = 9 进入循环。 这就是为什么第一个打印值是 9 等。 在最后一个循环 x= 1 中, 条件是真实的 。 根据非自动运算符, 在打印时, 值将修改为 x = 0 。 现在, x = 0, 它会将条件 (x > 0) 评估为假值, 而循环退出时则评估为假值 。
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 引入一些更先进的环绕功能。 首先, 抓住我, 我们可以建立一个反环绕行, 并将其偏移到 std:: ostream 上。 但是, i 的速度是执行定义的, 这样我们可以使用新的 C++20 速度操作器 i 来加速它。 我们还必须用建筑墙来捕捉它, 否则, 我就会留下范围, 并去引用它引起不确定的行为 。 要指定分隔符, 我们可以使用 :
std::cout \
sep
在那里,我们有一个循环 从67到1。
- >不是操作员,而是 --(降级后)和 >(比比较大)的并列。
循环将更熟悉于 :
#include <stdio.h>
int main() {
int x = 10;
while (x-- > 0) { // x goes to 0
printf("%d ", x);
}
}
此循环是一个典型的词组, 用来罗列10( 被排除的上界) 和0( 包含的下界) 之间的值, 有助于在从最后到第一个数组的元素上循环 。
初始值 10 是迭代的总数(例如数组的长度), 1 加上循环中使用的第一个值。 0 是循环中 x 的最后值, 因此注释 x 到 0 。
注意循环完成后 x 的值为 - 1 。
请注意,如果 x 具有大小_ t 等无符号型号, 则此环会以同样的方式运行, 这对于( i = long-1; i 0; i- ) 而言, 与天真的替代型号( i = long- 1; i 0; i- ) 而言, 其优势很大 。
因此,我实际上是这个令人惊讶的语法的粉丝:(x - > 0),而(x - > 0),我发现这像(;);)与(l)一样,很优雅和优雅。 (l)与(l)相似。 (l)也使用其他语言,其语法受C++、目标-C、java、 Java、javascript、C#的启发,仅举几个例子。
这就是你的意思。
while((x--) > 0)
我们在童年的时候听到,
不要停,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走,让走
当逗号混淆时
停止,不要松手。
现在在编程中也发生同样的情况, 空间制造混乱。 : D :
相对于常规箭头操作员 (- >) , 您可以使用穿甲箭头操作员 : -- x> (注意箭头上那些尖锐的条纹) 。 它会为穿甲添加+1 。 因此它比常规箭头操作员更快完成环形 1 迭代 。 请尝试 :
int x = 10;
while( --x> 0 )
printf("%d ", x);
您使用的操作员称为“ 降级和时测试 ” 。 C99 标准对它的定义是 C99 标准,这是 C 编程语言标准的最新版本。 C99 标准在 C 语言中增加了一些新的操作员, 包括“ 降级和时测试” 操作员。 许多 C++ 编译员将这些新的操作员作为 C++ 语言的扩展。
以下是没有使用“降级和测试”操作员的代码:
#include <stdio.h>
int main()
{
int x = 10;
while (x > 0)
{
printf("%d ", x);
x--;
}
}
在此代码版本中, 循环时使用 > 运算符测试 x 是否大于 0 。 x- 语句用于在循环每次迭代结束时将 x 降为 1 。
