如果我们使用if（a>；b>；c）#a大于所有三个，则结果为false

我用C语言执行了下面的代码

#include<stdio.h>
#include<conio.h>
void main()
{
        int a=15,b=10,c=5;
        if(a>b>c)
           printf("True");
        else
           printf("False");
        getch();
}

#包括
#包括
void main（）
{
INTA=15，b=10，c=5；
如果（a>b>c）
printf（“真实”）；
其他的
printf（“假”）；
getch（）；
}

输出： 假的 请解释一下为什么？

< P> C或C++中没有三元（或链式）<代码> > /Cuff>操作符。因此，当计算从左到右进行时，表达式的计算结果为

（（a>b）>c）

在C语言中，真表达式计算为

1

，假表达式计算为

0

。在C++中，我的记忆是，它们评估为布尔<代码>真< /COD>或<代码> false <代码>，但是这些类型转换为<代码> 1 <代码>或<代码> 0 > /代码>，所以情况大致相同。 使用该原则，

a>b

将在

a>b

的情况下计算为

1

，否则计算为

0

。因此，如果

a>b

，则整个表达式的计算结果为

1>c

，否则为

0>c

。由于

c

不止一个，因此

1>c

和

0>c

都不是真的，并且输出总是

0

或false，程序将打印

false

<> P>为了实现我真正怀疑你真正想要的，使用<代码>（（A>B）& &（b>C））< /C> > /P> < P> C或C++中没有三元（或链式）<代码> > /Cuth>运算符。因此，当计算从左到右进行时，表达式的计算结果为

（（a>b）>c）

在C语言中，真表达式计算为

1

，假表达式计算为

0

。在C++中，我的记忆是，它们评估为布尔<代码>真< /COD>或<代码> false <代码>，但是这些类型转换为<代码> 1 <代码>或<代码> 0 > /代码>，所以情况大致相同。 使用该原则，

a>b

将在

a>b

的情况下计算为

1

，否则计算为

0

。因此，如果

a>b

，则整个表达式的计算结果为

1>c

，否则为

0>c

。由于

c

不止一个，因此

1>c

和

0>c

都不是真的，并且输出总是

0

或false，程序将打印

false

<> P>为了实现我真正怀疑你真正想要的，使用<代码>（（A>B）& &（b>C））< /C> > /P> < P> C或C++中没有三元（或链式）<代码> > /Cuth>运算符。因此，当计算从左到右进行时，表达式的计算结果为

（（a>b）>c）

在C语言中，真表达式计算为

1

，假表达式计算为

0

。在C++中，我的记忆是，它们评估为布尔<代码>真< /COD>或<代码> false <代码>，但是这些类型转换为<代码> 1 <代码>或<代码> 0 > /代码>，所以情况大致相同。 使用该原则，

a>b

将在

a>b

的情况下计算为

1

，否则计算为

0

。因此，如果

a>b

，则整个表达式的计算结果为

1>c

，否则为

0>c

。由于

c

不止一个，因此

1>c

和

0>c

都不是真的，并且输出总是

0

或false，程序将打印

false

<> P>为了实现我真正怀疑你真正想要的，使用<代码>（（A>B）& &（b>C））< /C> > /P> < P> C或C++中没有三元（或链式）<代码> > /Cuth>运算符。因此，当计算从左到右进行时，表达式的计算结果为

（（a>b）>c）

在C语言中，真表达式计算为

1

，假表达式计算为

0

。在C++中，我的记忆是，它们评估为布尔<代码>真< /COD>或<代码> false <代码>，但是这些类型转换为<代码> 1 <代码>或<代码> 0 > /代码>，所以情况大致相同。 使用该原则，

a>b

将在

a>b

的情况下计算为

1

，否则计算为

0

。因此，如果

a>b

，则整个表达式的计算结果为

1>c

，否则为

0>c

。由于

c

不止一个，因此

1>c

和

0>c

都不是真的，并且输出总是

0

或false，程序将打印

false

---

要实现我强烈怀疑你真正想要的，请使用

（（a>b）和&（b>c））

（

a>b

）=>1，

1>c

为0。

如果（a>b>c）与
如果（（a>b）>c
，
a>b
为0或1，这总是
<5
。该语法仅在
Python中有效（据我所知），大多数其他语言不允许这样的链式表达式。@Cyber:Scheme也允许这样做，即
（<2 3 4）=>#t
，主要是因为
关联性是从左到右的，因此
a>b
首先计算。（
a>b
）=>1，
1>c
为0。
if（a>b>c）
与
if（（a>b>c）相同，
a>b
是0或1，总是
<5
。这种语法只在
Python
中有效（据我所知），大多数其他语言都不允许这样的链式表达式。@Cyber:Scheme也允许这样做，即
（<2 3 4）=>#t
主要是因为
关联性是从左到右的，因此，首先计算
a>b
（
a>b
）=>1，
1>c
为0。
if（a>b>c）
与
if（（a>b）>c）
相同，
a>b
为0或1，总是
<5
。该语法仅在
Python
中有效（据我所知），大多数其他语言不允许这样的链式表达式。@Cyber:Scheme也允许这样做，即
（<2 3 4）=>#t
，主要是因为
关联性是从左到右的，因此
a>b
首先计算。（
a>b
）=>1，
1>c
为0。
if（a>b>c）
与
if（（a>b>c）相同，
a>b
是0或1，它总是
<5
。这种语法只在
Python
中有效（据我所知），大多数其他语言都不是