The QuickStart Boolean operator (Boolean operator) is an operator that evaluates to either true or false. C # provides several very useful Boolean operators, the simplest of which is the not (negation) operator, which uses an exclamation point (!). to indicate that.! the operator asks for a Boolean value of the inverse value. In the example above, if the variable Areyouready value is true, then the expression!areyouready evaluates to False.
understanding equality and relational operators
The two more commonly used Boolean operators are equal (= =) and unequal (!=) operators. Using these two two-element operators, you can determine whether a value is equal to another value of the same type. Table 1 shows how these operators work, taking an int variable named age as an example.
Table 1 Boolean operators
operator |
Meaning |
Example |
Result (assuming age = 42) |
== |
Equals |
Age = = 100 |
False |
!= |
Not equal to |
Age!= 0 |
True |
Closely related to the above two operators is the relational operator (relational operator). Using these operators, you can determine whether a value is less than or greater than another value of the same type. Table 2 shows you how to use these operators.
Table 2 relational operators
operator |
Meaning |
Example |
Result (assuming age = 42) |
&< |
Less than |
Age &< 21 |
False |
&<= |
Less than or equal to |
Age &<= 18 |
False |
> |
Greater than |
Age > 16 |
True |
>= |
Greater than or equal to |
Age >= 30 |
True |
Be careful not to confuse the equality operator (= =) with the assignment operator (=). Like
x==ySuch code compares x and Y, and returns True if two values are the same. Instead, like
x=ySuch code assigns the value of Y to X.
Understanding conditional logical operators
C # also provides two additional Boolean operators: the Logical AND (logical AND) operators, which use the
&&and the logical or (logical OR) operator, which uses | | to indicate. These two operations Fu Shi called conditional logical operators (conditional logical operator). Their role is to combine different Boolean expressions to form a larger expression. The similarity between the two two-dollar operators and the equality and relational operators is that their results are true or false. The difference is that the value (operand) that they manipulate must itself be true or false.
The,&& operator evaluates to true only if the two Boolean expressions that are operands are true. For example, the following statement assigns a true value to validpercentage only if the value of the percent is greater than or equal to zero, and the percent value is less than or equal to 100:
BOOL Validpercentage;
Validpercentage = (Percent >= 0) && (Percent &<= 100);
A common mistake for beginners is to name the percent variable only once when merging two Tests, as follows:
Percent >= 0 && &<= 100//This statement cannot be compiled
Using parentheses helps to avoid this type of error and also helps clarify expressions. For example, you can compare the following two expressions:
Validpercentage = percent >= 0 && percent &<= 100
Validpercentage = (Percent >= 0) && (Percent &<= 100)
Two expressions return the same value because the operator && precedence is lower than >= and &<=. However, the second expression shows its purpose in a clearer and more understandable way.
Two operator any one is true, operator | | The evaluated result is true. Using the operator | |, we can determine whether any one of the two conditions is set up. If the value of percent is less than 0, or if the value of percent is greater than 100, the following statement assigns the value true to Invalidpercentage:
BOOL Invalidpercentage;
Invalidpercentage = (Percent &< 0) | | (Percent > 100);
Short-circuit evaluation
Operators && and | | Has a feature called short-circuit evaluation (short circuiting). Sometimes it is not necessary to evaluate two operands at all. For example, assuming that the left operand of the operator && evaluates to false, the result of the entire expression must be false, regardless of the value of the right-hand operand. Similarly, if the operator | | Evaluates to true for the left operand, the result of the entire expression is definitely true. In these cases, operator && and | | The evaluation of the Boolean expression to the right is bypassed. Here are some examples:
(Percent >= 0) && (Percent &<= 100)
In this expression, if the value of the percent is less than 0, then the boolean expression on the operator && left evaluates to False. This value means that the result of the entire expression must be false, regardless of the expression on the right. Therefore, the expression on the right side is not evaluated.
(Percent &< 0) | | (Percent > 100)
In this expression, if the value of percent is less than 0, the operator | | The Boolean expression on the left evaluates to True. This value means that the result of the entire expression must be true. Therefore, the expression on the right side is not evaluated.
If you can design an expression carefully to use conditional logic operators, you can avoid unnecessary work to improve the performance of your code. Put the easy, simple Boolean expression on the left side of the conditional logic operator and put the more complex expression on the right. In many cases, the program does not require a complex expression.
|
operator Precedence and associativity summary
Table 3 summarizes the precedence and associativity of all the operators that have been learned so far. Operators of the same category have the same precedence. Operators in a higher category take precedence over operators in lower categories.
Table 3 Operator Summary
Category
|
operator
|
Description
|
Combination of
|
Main (Primary)
|
()
++
--
|
Override Priority
After increment
After descending
|
Left
|
One dollar (unary)
|
!
+
-
++
--
|
Logical not
Add
Reducing
Forward increments
Before descending
|
Left
|
Multiply (multiplicative)
|
*
/
%
|
By
Except
Find Yu
|
Left
|
Add (additive)
|
+
-
|
Add
Reducing
|
Left
|
Relationship (relational)
|
&<
&<=
>
>=
|
Less than
Less than or equal to
Greater than
Greater than or equal to
|
Left
|
Equality (equality)
|
==
!=
|
Equals
Not equal to
|
Left
|
Conditions and (Conditional and)
|
&&
|
Logical AND
|
Left
|
Condition or (Conditional or)
|
||
|
Logical OR
|
Left
|
Assign Value (Assignment)
|
=
|
|
Right |