CS1L12——逻辑运算符

逻辑运算符

对两个 bool​ 进行逻辑运算，返回 bool​ 值

  1. 逻辑与

    符号 &&​，规则 对两个 bool​ 值进行逻辑计算 有假则假 同真为真

    ​? && ?​，?​ 可以是写死的 bool​ 变量 或者 bool​ 值，还可以是条件运算符相关表达式

    1
    2
    3
    4
    5
    6
    7
    8
    bool result = true && false;
    Console.WriteLine(result);
    result = true && true;
    Console.WriteLine(result);
    result = false && true;
    Console.WriteLine(result);
    result = false && false;
    Console.WriteLine(result);

    输出：

    1
    2
    3
    4
    False
    True
    False
    False

    ​bool​ 相关的类型 条件运算符
    与 和 或 这样的逻辑运算符的优先级低于条件运算符低于算数运算符

    1
    2
    3
    4
    5
    6
    7
    result = 3 > 1 && 1 < 2;
    result = 3 > 1 && 1 < 2 - 1;
    Console.WriteLine(result);

    int i = 3;
    result = i > 1 && i < 5;
    Console.WriteLine(result);

    输出：

    1
    2
    False
    True

    多个逻辑与 组合使用
    在没有括号的情况下，从左往右看；有括号先看括号内
    一旦遇到false就直接false, 无视后续的运算，尤其注意自增减，若被无视，则自增减不会发生

    1
    2
    3
    result = i2 > 1 && i2 < 5 && i > 1 && i++ < 5;
    Console.WriteLine(result);
    Console.WriteLine(i);

    输出：

    1
    2
    False
    3

  2. 逻辑或

    符号 ||​
    规则 对两个 bool​ 值进行逻辑运算 有真则真 同假则假

    ​? || ?​，?​ 可以是写死的 bool​ 变量 或者 bool​ 值，还可以是条件运算符相关表达式

    一旦遇到 true​ 就直接 true​ , 无视后续的运算，尤其注意自增减，若被无视，则自增减不会发生

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    result = true || false;
    Console.WriteLine(result);
    result = true || true;
    Console.WriteLine(result);
    result = false || true;
    Console.WriteLine(result);
    result = false || false;
    Console.WriteLine(result);

    result = 3 > 10 || 3 < 5;
    Console.WriteLine(result);

    int a = 5;
    int b = 11;
    result = a > 1 || b < 20 || a > 5;
    Console.WriteLine(result);

    输出：

    1
    2
    3
    4
    5
    6
    True
    True
    True
    False
    True
    True

  3. 逻辑非

    符号 !​
    规则 对一个 bool​ 值进行取反 真变假 假变真

    1
    2
    3
    4
    5
    6
    7
    result = !true;
    Console.WriteLine(result);
    result = !false;
    Console.WriteLine(result);

    result = !!true;
    Console.WriteLine(result);

    输出：

    1
    2
    3
    False
    True
    True

    注意：逻辑非的优先级高于算数运算符高于条件运算符，用的时候注意适时使用括号

    1
    2
    3
    4
    5
    result = !(3 > 2);
    Console.WriteLine(result);
    a = 5;
    result = !(a > 5);
    Console.WriteLine(result);

    输出：

    1
    2
    False
    True

逻辑运算符混合使用的优先级问题

规则： !​ 的使用优先级高于算数运算符高于条件运算符，||​ 低于 &&​ ，而低于条件运算符低于算数运算符

1
2
3
4
5
6
7
8
9
10
11
12
bool gameOver = false;
int hp = 100;
bool isDead = false;
bool isMustOver = true;

result = gameOver || hp + 100 < 0 && !isDead || isMustOver;
// false || 100 + 100 < 0 && true || true
// false || 200 < 0 && true || true;
// false || false && true || true;
// false || false || true;
// true
Console.WriteLine(result);

输出：

1
True

逻辑运算符短路规则

多个逻辑组合使用时，在没有括号的情况下，从左往右看，只要 逻辑与 或者 逻辑或 的组合式里左边满足了条件
就会抛弃后续的运算，尤其注意自增减，若被无视，则自增减不会发生

例如：

1
2
3
4
result = i2 > 1 && i2 < 5 && i > 1 && i++ < 5;
Console.WriteLine(result);
Console.WriteLine(i);
//逻辑与，一旦遇到false就直接false, 无视后续的运算，尤其注意自增减，若被无视，则自增减不会发生

输出：

1
2
False
3

本课源代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
namespace lesson12逻辑运算符
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("逻辑运算符");
            //对两个bool进行逻辑运算，返回bool值
            #region 逻辑与
            //符号 &&
            //规则 对两个bool值进行逻辑计算 有假则假 同真为真

            bool result = true && false;
            Console.WriteLine(result);
            result = true && true;
            Console.WriteLine(result);
            result = false && true;
            Console.WriteLine(result);
            result = false && false;
            Console.WriteLine(result);

            //bool相关的类型 条件运算符
            // 与 和 或 这样的逻辑运算符的优先级低于条件运算符低于算数运算符
            result = 3 > 1 && 1 < 2;
            result = 3 > 1 && 1 < 2 - 1;
            Console.WriteLine(result);

            int i = 3;
            result = i > 1 && i < 5;
            Console.WriteLine(result);

            //多个逻辑与 组合使用
            int i2 = 5;
            //在没有括号的情况下，从左往右看
            //有括号先看括号内
            result = i2 > 1 && i2 < 5 && i > 1 && i++ < 5;
            Console.WriteLine(result);
            Console.WriteLine(i);
            //一旦遇到false就直接false, 无视后续的运算，尤其注意自增减，若被无视，则自增减不会发生

            // ? && ?
            // ? 可以是写死的bool变量 或者 bool值
            // 还可以是条件运算符相关
            #endregion

            #region 逻辑或
            //符号 ||
            //规则 对两个bool值进行逻辑运算 有真则真 同假则假
            result = true || false;
            Console.WriteLine(result);
            result = true || true;
            Console.WriteLine(result);
            result = false || true;
            Console.WriteLine(result);
            result = false || false;
            Console.WriteLine(result);

            result = 3 > 10 || 3 < 5;
            Console.WriteLine(result);

            int a = 5;
            int b = 11;
            result = a > 1 || b < 20 || a > 5;
            Console.WriteLine(result);
            //一旦遇到true就直接true, 无视后续的运算，尤其注意自增减，若被无视，则自增减不会发生

            //  // ? && ?
            // ? 可以是写死的bool变量 或者 bool值
            // 还可以是条件运算符相关
            #endregion

            #region 逻辑非
            //符号 ！
            //规则 对一个bool值进行取反 真变假 假变真
            result = !true;
            Console.WriteLine(result);
            result = !false;
            Console.WriteLine(result);

            result = !!true;
            Console.WriteLine(result);

            //注意：逻辑非的优先级高于算数运算符高于条件运算符，用的时候注意适时使用括号
            result = !(3 > 2);
            Console.WriteLine(result);
            a = 5;
            result = !(a > 5);
            Console.WriteLine(result);

            #endregion

            #region 逻辑运算符混合使用的优先级问题
            //规则： ! 的使用优先级高于算数运算符高于条件运算符
            //       || 低于 && ，而低于条件运算符低于算数运算符
            bool gameOver = false;
            int hp = 100;
            bool isDead = false;
            bool isMustOver = true;

            result = gameOver || hp + 100 < 0 && !isDead || isMustOver;
            // false || 100 + 100 < 0 && true || true
            // false || 200 < 0 && true || true;
            // false || false && true || true;
            // false || false || true;
            // true
            Console.WriteLine(result);

            #endregion

            #region 逻辑运算符短路规则
            //多个逻辑组合使用时
            //在没有括号的情况下，从左往右看
            //只要 逻辑与 或者 逻辑或 的组合式里左边满足了条件
            //就会抛弃后续的运算，尤其注意自增减，若被无视，则自增减不会发生
            //例如：
            result = i2 > 1 && i2 < 5 && i > 1 && i++ < 5;
            Console.WriteLine(result);
            Console.WriteLine(i);
            //逻辑与，一旦遇到false就直接false, 无视后续的运算，尤其注意自增减，若被无视，则自增减不会发生
            #endregion
        }
    }
}

‍