第三单元运算符、控制台、转义字符-526互联

1. 运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C# 有丰富的内置运算符，分类如下：

算术运算符
关系运算符
逻辑运算符
复合赋值运算符
位运算符
其他运算符

本文章将逐一讲解算术运算符、关系运算符、逻辑运算符、复合赋值运算符。

运算符优先级（由高到低）

类别	运算符	结合性
后缀	() [] -> . ++ - -	从左到右
一元	+ - ! ~ ++ - - (type)* & sizeof	从右到左
乘除	* / %	从左到右
加减	+ -	从左到右
移位	<< >>	从左到右
关系	< <= > >=	从左到右
相等	== !=	从左到右
位与 AND	&	从左到右
位异或 XOR	^	从左到右
位或 OR	\|	从左到右
逻辑与 AND	&&	从左到右
逻辑或 OR	\|\|	从左到右
条件	?:	从右到左
赋值	= += -= *= /= %=>>= <<= &= ^= \|=	从右到左
逗号	,	从左到右

算术运算符

算术预算符又分为一元运算符和二元运算符。

一元：++、--

对于向加加或者减减这样只需要一个操作数就能完成的运算，称为一元运算符。
二元：*、/、%、+、-，=

+ 、-、 *、 /、 %、对于这些需要两个或以上才能完成运算操作符，称为二元运算符。

运算符	描述
+	加运算符
-	减运算符
++	增量运算符
--	减量运算符
*	乘法运算符
/	除法运算符
%	余数运算符
=	赋值运算符

= 赋值运算符

int a = 5; // 将5赋值给 整形 a 变量
bool b = false; // 将false 赋值给 b 变量

+ 加运算符

int a =5;
int b =10;
int c = a + b;
Console.WriteLine(c); // 输出结果：15

- 减运算符

int a =5;
int b =10;
int c = b - a;
Console.WriteLine(c); // 输出结果：5

x 乘法运算符

int a =5;
int b =10;
int c = a * b;
Console.WriteLine(c); // 输出结果：50

/ 除法运算符

int a =5;
int b =10;
int c = b / a;
Console.WriteLine(c); // 输出结果：2
Console.WriteLine(a / b ); // 输出结果：0


double aa = 2.4;
Console.WriteLine(aa / 8 ); // 输出结果0.3

% 求余运算符

int a =10;
int b =3;
int c = a % b;
Console.WriteLine(c); // 输出结果：1
Console.WriteLine(a / b ); // 输出结果：0

// 注意求余，一般仅限于 整形类型(short,int,long)

++ 自增运算符

int i = 10;
i++; // i =11 , 相当于 i = i+1;
++i  // i = 12, 相当于 i = i+1;

i++ 与 ++ i的区别如下：

int a = 10;
int b = a++; // b = 10
Console.WriteLine($"a的值={a},b={b}"); // 输出结果：a=11,b=10
int a = 10;
int b = ++a; // b = 11,a =11
Console.WriteLine($"a的值={a},b的值={b}"); // 输出结果：a=11,b=11

-- 自减运算符

int i = 10;
i--; // i =9 , 相当于 i = i-1;
--i  // i = 8, 相当于 i = i-1;

i-- 与 -- i的区别同 i++, ++i 一样。

练习题1

int a = 10;
int b =a ;
int c = a++ + ++b;
int d = c-- -b-- +a;

Console.WriteLine($"a={a},b={b},c={c},d={d}");

练习题2

int a = 10;
int b = a;

a = a++;
b += a;
int c = b++ + a; 
int d = c++ * ++a; // 考查运算符的优先级
Console.WriteLine($"a={a},b={b},c={c},d={d}");

关系运算符

下表显示了 C# 支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

运算符	描述	实例
==	检查两个操作数的值是否相等，如果相等则条件为真。	(A == B) 不为真。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。	(A > B) 不为真。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。	(A < B) 为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	(A >= B) 不为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。	(A <= B) 为真。

实例

请看下面的实例，了解 C# 中所有可用的关系运算符：

using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 21;
              int b = 10;

              if (a == b)
              {
                  Console.WriteLine("Line 1 - a 等于 b");
              }
              else
              {
                  Console.WriteLine("Line 1 - a 不等于 b");
              }
              if (a < b)
              {
                  Console.WriteLine("Line 2 - a 小于 b");
              }
              else
              {
                  Console.WriteLine("Line 2 - a 不小于 b");
              }
              if (a > b)
              {
                  Console.WriteLine("Line 3 - a 大于 b");
              }
              else
              {
                  Console.WriteLine("Line 3 - a 不大于 b");
              }
              /* 改变 a 和 b 的值 */
              a = 5;
              b = 20;
              if (a <= b)
              {
                 Console.WriteLine("Line 4 - a 小于或等于 b");
              }
              if (b >= a)
              {
                 Console.WriteLine("Line 5 - b 大于或等于 a");
              }
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 a

逻辑运算符

下表显示了 C# 支持的所有逻辑运算符。假设变量 A 为布尔值 true，变量 B 为布尔值 false，则：

运算符	描述	实例
&&	称为逻辑与运算符。如果两个操作数都非零，则条件为真。	(A && B) 为假。
\|\|	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。	(A \|\| B) 为真。
!	称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。	!(A && B) 为真。

实例

请看下面的实例，了解 C# 中所有可用的逻辑运算符：

using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            bool a = true;
            bool b = true;
           
            if (a && b)
            {
               Console.WriteLine("Line 1 - 条件为真");
            }
            if (a || b)
            {
                Console.WriteLine("Line 2 - 条件为真");
            }
            /* 改变 a 和 b 的值 */
            a = false;
            b = true;
            if (a && b)
            {
                Console.WriteLine("Line 3 - 条件为真");
            }
            else
            {
                Console.WriteLine("Line 3 - 条件不为真");
            }
            if (!(a && b))
            {
                Console.WriteLine("Line 4 - 条件为真");
            }
            Console.ReadLine();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Line 1 - 条件为真
Line 2 - 条件为真
Line 3 - 条件不为真
Line 4 - 条件为真

十进制与二进制相互转换

小学数学老师让我们数数字的时候为什么只有：0,1,2,3,4,5,6,7,8,9 ? 为什么第十位的写法是 10 呢？

答：我们从小到大，学的数学都是十进制。9 是十进制中最大的数字，所以9后面的那个数字必须进一位变成两位数，原来的个位数以0补齐，所以这两位就变成 10。

计算机中为什么只认识二进制？ cpu的电路中，只有两种电信号，“1”表示通电，“0”表示断电。所以二进制中只有0，1。于是在二进制中，必须逢2 进1，即 10。3 就是11，4 就是 100，5 就是101，6 就是110....

二进制转十进制

十进制转二进制

位运算符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

p	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

下表列出了 C# 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：

运算符	描述	实例
&	（位与）有0即为0	(A & B) 将得到 12，即为 0000 1100
\|	（位或）有1即为1	(A \| B) 将得到 61，即为 0011 1101
^	（位异或）全0 或全1 才为0	(A ^ B) 将得到 49，即为 0011 0001
~	（位取反）按位取反运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0，包括符号位。	(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
<<	二进制左移运算符。左操作数的值向左移动右操作数指定的位数。	A << 2 将得到 240，即为 1111 0000
>>	二进制右移运算符。左操作数的值向右移动右操作数指定的位数。	A >> 2 将得到 15，即为 0000 1111， B >> 2 将得到 3，即为 0000 0011

实例

请看下面的实例，了解 C# 中所有可用的位运算符：

using System;
namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 60;            /* 60 = 0011 1100 */  
            int b = 13;            /* 13 = 0000 1101 */
            int c = 0;          

             c = a & b;           /* 12 = 0000 1100 */
             Console.WriteLine("Line 1 - c 的值是 {0}", c );

             c = a | b;           /* 61 = 0011 1101 */
             Console.WriteLine("Line 2 - c 的值是 {0}", c);

             c = a ^ b;           /* 49 = 0011 0001 */
             Console.WriteLine("Line 3 - c 的值是 {0}", c);

             c = ~a;               /*-61 = 1100 0011 */
             Console.WriteLine("Line 4 - c 的值是 {0}", c);

             c = a << 2;     /* 240 = 1111 0000 */
             Console.WriteLine("Line 5 - c 的值是 {0}", c);

             c = a >> 2;     /* 15 = 0000 1111 */
             Console.WriteLine("Line 6 - c 的值是 {0}", c);
            Console.ReadLine();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15

赋值运算符

下表列出了 C# 支持的赋值运算符：

运算符	描述	实例
=	简单的赋值运算符，把右边操作数的值赋给左边操作数	C = A + B 将把 A + B 的值赋给 C
+=	加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数	C += A 相当于 C = C + A
-=	减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数	C -= A 相当于 C = C - A
*=	乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数	C = A 相当于 C = C A
/=	除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数	C /= A 相当于 C = C / A
%=	求模且赋值运算符，求两个操作数的模赋值给左边操作数	C %= A 相当于 C = C % A
<<=	左移且赋值运算符	C <<= 2 等同于 C = C << 2
>>=	右移且赋值运算符	C >>= 2 等同于 C = C >> 2
&=	按位与且赋值运算符	C &= 2 等同于 C = C & 2
^=	按位异或且赋值运算符	C ^= 2 等同于 C = C ^ 2
\|=	按位或且赋值运算符	C \|= 2 等同于 C = C \| 2

实例

请看下面的实例，了解 C# 中所有可用的赋值运算符：

using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 21;
            int c;

            c = a;
            Console.WriteLine("Line 1 - =  c 的值 = {0}", c);

            c += a;
            Console.WriteLine("Line 2 - += c 的值 = {0}", c);

            c -= a;
            Console.WriteLine("Line 3 - -=  c 的值 = {0}", c);

            c *= a;
            Console.WriteLine("Line 4 - *=  c 的值 = {0}", c);

            c /= a;
            Console.WriteLine("Line 5 - /=  c 的值 = {0}", c);

            c = 200;
            c %= a;
            Console.WriteLine("Line 6 - %=  c 的值 = {0}", c);

            c <<= 2;
            Console.WriteLine("Line 7 - <<=  c 的值 = {0}", c);

            c >>= 2;
            Console.WriteLine("Line 8 - >>=  c 的值 = {0}", c);

            c &= 2;
            Console.WriteLine("Line 9 - &=  c 的值 = {0}", c);

            c ^= 2;
            Console.WriteLine("Line 10 - ^=  c 的值 = {0}", c);

            c |= 2;
            Console.WriteLine("Line 11 - |=  c 的值 = {0}", c);
            Console.ReadLine();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15

其他运算符

下表列出了 C# 支持的其他一些重要的运算符，包括 sizeof、typeof 和 ? :。

运算符	描述	实例
sizeof()	返回数据类型的大小。	sizeof(int)，将返回 4.
typeof()	返回 class 的类型。	typeof(StreamReader);
&	返回变量的地址。	&a; 将得到变量的实际地址。
*	变量的指针。	*a; 将指向一个变量。
? :	条件表达式	如果条件为真 ? 则为 X : 否则为 Y
is	判断对象是否为某一类型。	If( Ford is Car) // 检查 Ford 是否是 Car 类的一个对象。
as	强制转换，即使转换失败也不会抛出异常。	`Object obj = new StringReader("Hello"); StringReader r = obj as StringReader;`

using System;

namespace OperatorsAppl
{
   
   class Program
   {
      static void Main(string[] args)
      {
         
         /* sizeof 运算符的实例 */
         Console.WriteLine("int 的大小是 {0}", sizeof(int));
         Console.WriteLine("short 的大小是 {0}", sizeof(short));
         Console.WriteLine("double 的大小是 {0}", sizeof(double));
         
         /* 三元运算符的实例 */
         int a, b;
         a = 10;
         b = (a == 1) ? 20 : 30;
         Console.WriteLine("b 的值是 {0}", b);

         b = (a == 10) ? 20 : 30;
         Console.WriteLine("b 的值是 {0}", b);
         Console.ReadLine();
          
          object obj = 3.14m;
            // c# 8.0 
            if (obj is decimal d)
            {
                Console.WriteLine(d);
            }

            Person p = new Person();
            object obj2 = p;
            Person p2 = obj2 as Person;
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

int 的大小是 4
short 的大小是 2
double 的大小是 8
b 的值是 30
b 的值是 20
3.14m

2. Console 类控制台

表示控制台应用程序的标准输入流、输出流和错误流。此类不能被继承。

常用属性

Title 标题

设置或者获取标题。

Console.Title = "C# 入门2022(NetCore版本)";
Console.WriteLine("C# 入门2022(NetCore版本)");
Console.ReadLine();// 等待控制台输入，作用：防止程序结束，看不到效果

ForegroundColor 字体颜色

设置或者获取控制台字体颜色

Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("阶段一学习：C# 入门2022(NetCore版本)");
Console.WriteLine("阶段二学习：SqlServer 数据库与数据访问)");
Console.ResetColor();// 让颜色还原
Console.WriteLine("阶段三学习：JavaScript 与 JQuery)");

BackgroundColor 背景色

设置或者获取控制台的背景颜色

Console.BackgroundColor = ConsoleColor.Green;
Console.WriteLine("******************************************************");
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("欢迎来到王者荣耀");
Console.WriteLine("******************************************************");

常用方法

方法	描述
Write	向控制台输出内容后不换行
WriteLine	向控制台输出内容后换行
Read	从控制台上读取一个字符
ReadLine	从控制台上读取一行字符

Console.WriteLine("请输入一个字符串：");
string s = Console.ReadLine();
Console.WriteLine(s);
Console.Read(); // 暂停操作，等待用户输入，防止结果一闪而过

3. 转义字符

如果想要输出一段话,你的代码应该怎么写？

某度网盘下载速度居然"高达" 100Kb/s

作用

消除紧随其后的字符的原有含义，不同于字符原有的意义，用一些普通字符的组合来代替一些特殊字符，由于其组合改变了原来字符表示的含义，故称“转义”字符。

\n 换行
\r 回车
\t 制表符
\f 换页符
\b 退格
\a 响铃
\e escape（ASCII中的escape 字符）
\007 任何八进制值（这里是，007=bell(响铃)）
\x7f 任何十六进制值（这里是，007=bell）
\cC 一个控制符（这里是：Ctrl+c）
\ 反斜线
" 双引号
\l 下个字符小写
\L 接着的字符均小写直到\E
\u 下个字符大写
\U 接着的字符均大写直到\E
\Q 在 non-word 字符前加上(自动加转义符号)，直到\E
\E 结束\L,\E和\Q
\0 空格

//string str = "某度网盘下载速度居然"高达" 100Kb/s"; ;// 错误的写法
// 在字符串中，转义双引号
string str = "某度网盘下载速度居然\"高达\" 100Kb/s"; // 正确的写法


//string path = "D:\person\study\C# 2022入门（DotNetCore 版本）";// 错误的写法
// 转义路径
string path = "D:\\person\\study\\C# 2022入门（DotNetCore 版本）";// 正确的写法
Console.WriteLine(str);
Console.WriteLine(path);

5. 作业

某柱子，半径是 2.3，高是4，求其周长、底面积，体积。
随便定义一个年份数字，判断是润年还是平年。
随便定义三个数，用if语句和关系运算符把最大数和最大数找出来。
随便定义三个数，用条件表达式（?:）求出最大数和最大数。（能否写成一行代码？？）
随便定义一个成绩（0-100），然后用if else语句判断该成绩是优、良、中、及格还是不及格。（分数段自定义）。
定义变量 a 变量为5 ，b变量为10 ，试着把这两个值进行交互。（最终结果是a=10,b=5）

根据表达式，按要求写结果

int a = 20;// a=10100
int b = 8; // b = 1000

题一： a 与 b 的二进制 a=10100  b=1000
题二：a >> 3 的 十进制结果 与 二进制结果
题三：b << 1 的 十进制结果 与 二进制结果
题四：a|b 的 结果
题五：a & 2 的结果
题六：a ^ b 的 结果

视频教程：

誉尚学教育_誉尚学教育腾讯课堂官网 (qq.com)
或者：C# 最强入门编程(.Net 学习系列开山巨作)_哔哩哔哩_bilibili