user-0 提问: 明天参加c语言自学考试，有两个题不懂，麻烦大侠解答一下，谢谢。

回复:
user: user-1
content: 引用 1 楼 user-6 的回复:19.初始化x为整形，前半部分强制转换成float型，2/5=0.4，后半部分x是整型，3/5=0，相加就是0.4。 7.&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为非零时，整个运算结果才为1，否则，只要有一方为0，则结果为0。这里5&5=1，3&&4=1，相减等于0.还有这么解释的。。。

user: user-0
content: 我要结贴了，大家都会得分的！

user: user-0
content: 谢谢大家的回答，谢谢赵4老师！有帮助！我彻底看懂了！

user: user-0
content: 引用 4 楼 Saleayas 的回复:运算符的优先级的问题。  5 & 5 - 3 && 4 等同于 (5 & (5 - 3)) && 4 = (5 & 2) && 4 = 0 && 4 = 0  5 & 5 是等于 5 的。 && 和 & 的算法是不一致的。   谢谢回复，对我有很大的帮助。        2转2进制等于10         5转2进制等于101        按位与，就是：                                101                                                                   010     ===========                                                                                         000           ==========       =0。                        0&&4=0。

user: user-2
content: 仅供参考：//C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+

user: user-0
content: 引用 1 楼 user-6 的回复:19.初始化x为整形，前半部分强制转换成float型，2/5=0.4，后半部分x是整型，3/5=0，相加就是0.4。 7.&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为非零时，整个运算结果才为1，否则，只要有一方为0，则结果为0。这里5&5=1，3&&4=1，相减等于0. 谢谢1楼user-6的回复。但是5&5不是等于5吗？取自于位运算——       5转二进制——101。                     101                                                                101                                                     =         101

user: user-3
content: 第二题考算操作符的优先级。 相等于(5&（5-3))&&4

user: user-4
content: 运算符的优先级的问题。  5 & 5 - 3 && 4 等同于 (5 & (5 - 3)) && 4 = (5 & 2) && 4 = 0 && 4 = 0  5 & 5 是等于 5 的。 && 和 & 的算法是不一致的。

user: user-2
content: 不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！

user: user-5
content: 引用 1 楼 user-6 的回复:19.初始化x为整形，前半部分强制转换成float型，2/5=0.4，后半部分x是整型，3/5=0，相加就是0.4。 7.&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为非零时，整个运算结果才为1，否则，只要有一方为0，则结果为0。这里5&5=1，3&&4=1，相减等于0. +1

user: user-6
content: 19.初始化x为整形，前半部分强制转换成float型，2/5=0.4，后半部分x是整型，3/5=0，相加就是0.4。 7.&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为非零时，整个运算结果才为1，否则，只要有一方为0，则结果为0。这里5&5=1，3&&4=1，相减等于0.