CS1L9——算术运算符

算数运算符

算数运算符是用于数值类型变量计算的运算符，返回结果是数值

  1. “=”赋值符号

    先看右侧 再看左侧，将右侧的值赋值给左侧的变量

    1
    2
    3
    string myName = "SevenL";
    int myAge = 18;
    float myHeight = 175.66f;

  2. 算数运算符 + - * / %

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      //用自己计算，先算右侧结果再赋值左侧变量
      int i = 1;
      i = i + 1;  // 2
      Console.WriteLine(i);

      //连续计算，先算右侧结果再赋值左侧变量
      i = 12 + 23 + i;    //注意：这里的i用仍然是之前的值

      //初始化就计算，先算右侧结果再赋值左侧变量
      int i2 = i + 2345;   //注意：这里的i用仍然是之前的值
          //注意左边往往只有一个变量，而不会是算式
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      //用自己计算，先算右侧结果再赋值左侧变量
      int j = 1;
      j = j - 1;  // 0
      Console.WriteLine(i);

      //连续计算，先算右侧结果再赋值左侧变量
      j = j - 2 - 3;
      j = 1 - j;    //注意：这里的j用仍然是之前的值

      //初始化就计算，先算右侧结果再赋值左侧变量
      int j2 = j - 2345;   //注意：这里的i用仍然是之前的值
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      //用自己计算，先算右侧结果再赋值左侧变量
      int k = 1;
      k = k * 10; //10
      Console.WriteLine(k);

      //连续计算，先算右侧结果再赋值左侧变量
      k = 1 * 2 * 3;
      k = 2 * k;

      //初始化就计算，先算右侧结果再赋值左侧变量
      int k2 = k * 2;

    4. /
      注意：除法往往会出现小数，如果仍用整形变量会导致丢失小数部分

      1
      2
      3
      4
      5
      6
      7
      8
      //先算右侧结果再赋值左侧变量
      int chu = 1;
      chu = 10 / chu;// 10
          //注意：除法往往会出现小数，如果仍用整形变量会导致丢失小数部分

      //如果用浮点数来存储，运算时一定要有浮点数的特征
      float f = 1 / 2f;   //  注意！如果要用float浮点数注意要加f
      f = 1.1f / 1;

    5. %

      就是取余数

      1
      2
      int y = 4;
      y = 4 % 3;//余1

  3. 算数运算符的优先级

    优先级值得是混合运算时的运算顺序
    */%的优先级高于±，同优先级从左向右运算
    括号可以改变优先级，多组括号先算最里面的括号

    1
    2
    3
    4
    5
    6
    7
    //优先级值得是混合运算时的运算顺序
    //  */%的优先级高于+-，同优先级从左向右运算
    int a = 1 + 2 * 3 / 2 + 1 + 2 * 3; // 11
    Console.WriteLine(a);
    //  括号可以改变优先级，多组括号先算最里面的括号
    a = (1 + (1 + 2)) * 3 * (2 + 3);
    Console.WriteLine(a);

    输出：

    1
    2
    11
    60

  4. 算数运算符的复合运算符

    固定写法 运算符=
    += -= *= /= %=
    复合运算符是用于对变量自己的运算

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    //  固定写法 运算符=
    //  += -= *= /= %=
    //复合运算符是用于对变量自己的运算
    int i3 = 1;
    i3 = i3 + 1;
    i3 += 1;    //上句与这句是等同的
                //其他复合运算符同理

    i3 = 1;
    i3 -= i3 * 20 % 19;// 0
    Console.WriteLine(i3);
    //注意复合运算符只能用一种，不可能有-+=这种

  5. 算术运算符的自加减

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    //自增运算符 让自己加1
    i = 1;
    i++;    //先用i再加1
    ++i;    //先加1再用i

    i = 1;
    Console.WriteLine(i++);//1
                           //2
    Console.WriteLine(++i);//3

    //自减运算符 让自己减1
    i = 1;
    i--;    //先用i再减1
    --i;    //先减1再用i

    i = 1;
    Console.WriteLine(i--);//1
                           //0
    Console.WriteLine(--i);//-1

    //不存在自乘自除

本课源代码

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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
namespace lesson9算术运算符
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("算数运算符");
            //算数运算符是用于数值类型变量计算的运算符
            //返回结果是数值

            #region "="赋值符号
            //先看右侧 再看左侧，将右侧的值赋值给左侧的变量
            string myName = "文KRIFE齐";
            int myAge = 18;
            float myHeight = 175.66f;
            #endregion

            #region 算数运算符 +-*/%
            #region +
            //用自己计算，先算右侧结果再赋值左侧变量
            int i = 1;
            i = i + 1;  // 2
            Console.WriteLine(i);

            //连续计算，先算右侧结果再赋值左侧变量
            i = 12 + 23 + i;    //注意：这里的i用仍然是之前的值

            //初始化就计算，先算右侧结果再赋值左侧变量
            int i2 = i + 2345;   //注意：这里的i用仍然是之前的值
                                 //注意左边往往只有一个变量，而不会是算式
            #endregion

            #region -
            //用自己计算，先算右侧结果再赋值左侧变量
            int j = 1;
            j = j - 1;  // 0
            Console.WriteLine(i);

            //连续计算，先算右侧结果再赋值左侧变量
            j = j - 2 - 3;
            j = 1 - j;    //注意：这里的j用仍然是之前的值

            //初始化就计算，先算右侧结果再赋值左侧变量
            int j2 = j - 2345;   //注意：这里的i用仍然是之前的值
            #endregion

            #region *
            //用自己计算，先算右侧结果再赋值左侧变量
            int k = 1;
            k = k * 10; //10
            Console.WriteLine(k);

            //连续计算，先算右侧结果再赋值左侧变量
            k = 1 * 2 * 3;
            k = 2 * k;

            //初始化就计算，先算右侧结果再赋值左侧变量
            int k2 = k * 2;
            #endregion

            #region / 注意：除法往往会出现小数，如果仍用整形变量会导致丢失小数部分
            //先算右侧结果再赋值左侧变量
            int chu = 1;
            chu = 10 / chu;// 10
            //注意：除法往往会出现小数，如果仍用整形变量会导致丢失小数部分

            //如果用浮点数来存储，运算时一定要有浮点数的特征
            float f = 1 / 2f;   //  注意！如果要用float浮点数注意要加f
            f = 1.1f / 1;

            #endregion

            #region % 取余数
            int y = 4;
            y = 4 % 3;//余1
            #endregion

            #endregion

            #region 算数运算符的优先级
            //优先级值得是混合运算时的运算顺序
            //  */%的优先级高于+-，同优先级从左向右运算
            int a = 1 + 2 * 3 / 2 + 1 + 2 * 3; // 11
            Console.WriteLine(a);
            //  括号可以改变优先级，多组括号先算最里面的括号
            a = (1 + (1 + 2)) * 3 * (2 + 3);
            Console.WriteLine(a);
            #endregion

            #region 算数运算符的复合运算符
            //  固定写法 运算符=
            //  += -= *= /= %=
            //复合运算符是用于对变量自己的运算
            int i3 = 1;
            i3 = i3 + 1;
            i3 += 1;    //上句与这句是等同的
            //其他复合运算符同理

            i3 = 1;
            i3 -= i3*20%19;// 0
            Console.WriteLine(i3);
            //注意复合运算符只能用一种，不可能有-+=这种
            #endregion

            #region 算术运算符的自加减
            //自增运算符 让自己加1
            i = 1;
            i++;    //先用i再加1
            ++i;    //先加1再用i

            i = 1;
            Console.WriteLine(i++);//1
            //2
            Console.WriteLine(++i);//3

            //自减运算符 让自己减1
            i = 1;
            i--;    //先用i再减1
            --i;    //先减1再用i

            i = 1;
            Console.WriteLine(i--);//1
            //0
            Console.WriteLine(--i);//-1

            //不存在自乘自除
            #endregion

            #region 练习
            //1
            int age = 20;
            Console.WriteLine(age += 10);
            //2
            int r = 5;
            const float PI = 3.14159f;
            float S = PI * r * r;
            Console.WriteLine(S);
            float D = 2 * PI * r;
            Console.WriteLine(D);
            //3
            int g1 = 90;
            int g2 = 85;
            int g3 = 70;
            int t = g1 + g2 + g3;
            Console.WriteLine(t);
            float mean = t / 3f;
            Console.WriteLine(mean);
            //4
            Console.WriteLine("num1=31");
            Console.WriteLine("num2=30");
            Console.WriteLine("num3=41");
            //5
            a = 99;
            int b = 87;
            int c = b;
            b = a;
            a = c;

            a = 99;
            b = 87;

            a -= a - b;
            b += 12;
            //6
            int time = 987652;
            int days = time / (24 * 60 * 60);
            int hours = time % (24 * 60 * 60) / (60 * 60);
            int minute = time % (60 * 60) / 60;
            int second = time % 60;
            Console.WriteLine(days +" "+ hours +" "+ minute +" "+ second);
            #endregion
        }
    }
}