编程笔记

Appearance

【腾讯云】多款云产品1折起，买云服务器送免费机器，最长免费续3个月
【腾讯云】推广者专属福利，新客户无门槛领取总价值高达2860元代金券，每种代金券限量500张，先到先得。

08-运算符 ​

运算符是编程中的基础工具，用于对变量进行操作。C# 提供了丰富的运算符，涵盖了数学运算、逻辑判断、赋值操作以及对象比较等方面。以下是 C# 中常用运算符的详细分类与解释。

1. 算术运算符 ​

算术运算符用于执行基本的数学运算，如加法、减法、乘法、除法等。

运算符操作示例结果
​+​加法​5 + 3​结果为 8​
​-​减法​10 - 4​结果为 6​
​*​乘法​7 * 2​结果为 14​
​/​除法​10 / 2​结果为 5​
​%​取余​10 % 3​结果为 1​（余数）

示例代码： ​

csharp
int a = 5;
int b = a + 2;   // b = 7
int c = a * 3;   // c = 15
int d = c % 2;   // d = 1

注意： ​

  • ​ ​​ ​/​​​ ​ 运算符：对于整数相除，结果是整数（小数部分被截断）；对于浮点数相除，结果会保留小数。
  • ​ ​​ ​%​​​ ​ 运算符：用于求余数，特别常用于判断奇偶性或循环中的递增逻辑。

2. 自增运算符和自减运算符详解 ​

在 C# 中，自增和自减运算符是对变量进行加一或减一的简化操作符。它们广泛应用于循环、计数器、条件判断等场景。根据操作符位置的不同，自增和自减运算符分为前置和后置，它们的行为有所不同。

2-1. 自增运算符 ++​ ​

自增运算符 ++​ 用于将变量的值增加 1。它有两种形式：

  • 前置自增：在变量前使用，表示先增加变量的值，然后再使用这个新值。
  • 后置自增：在变量后使用，表示先使用变量的当前值，然后再将其增加 1。

示例： ​

csharp
int a = 5;
int b = ++a;  // 前置自增：a 先加 1，a = 6，然后 b = 6

int c = 5;
int d = c++;  // 后置自增：d 先赋值为 c 当前的值，即 5，然后 c 自增 1，c = 6

运行结果： ​

csharp
a = 6, b = 6   // 前置自增，a 和 b 都是 6
c = 6, d = 5   // 后置自增，d 先是 5，c 然后变成 6

2-2. 自减运算符 --​ ​

自减运算符 --​ 用于将变量的值减少 1。它也有两种形式：

  • 前置自减：在变量前使用，表示先减少变量的值，然后再使用这个新值。
  • 后置自减：在变量后使用，表示先使用变量的当前值，然后再将其减少 1。

示例： ​

csharp
int a = 5;
int b = --a;  // 前置自减：a 先减 1，a = 4，然后 b = 4

int c = 5;
int d = c--;  // 后置自减：d 先赋值为 c 当前的值，即 5，然后 c 自减 1，c = 4

运行结果： ​

csharp
a = 4, b = 4   // 前置自减，a 和 b 都是 4
c = 4, d = 5   // 后置自减，d 先是 5，c 然后变成 4

2-3. 前置与后置的区别 ​

  • 前置自增/自减 (++a​ / --a​)：先对变量进行加一或减一操作，再返回新的值。
  • 后置自增/自减 (a++​ / a--​)：先返回当前值，再对变量进行加一或减一操作。

示例对比： ​

csharp
int a = 5;
Console.WriteLine(++a);  // 输出：6，先自增 a，然后输出 a 的新值

int b = 5;
Console.WriteLine(b++);  // 输出：5，先输出 b 的当前值，然后再自增 b，b = 6

在前置运算符中，变量的值在执行当前语句之前就被修改，而后置运算符则在执行完当前语句后才修改变量的值。这在复杂的表达式或循环中显得尤为重要。

3. 赋值运算符 ​

赋值运算符用于将某个值赋给变量。除了基本的 =​ 赋值符，还有复合运算符，它结合了算术运算和赋值操作。

运算符操作示例解释
​=​赋值​a = 10​将 10​ 赋值给变量 a​
​+=​加法赋值​a += 5​等同于 a = a + 5​
​-=​减法赋值​a -= 3​等同于 a = a - 3​
​*=​乘法赋值​a *= 2​等同于 a = a * 2​
​/=​除法赋值​a /= 2​等同于 a = a / 2​
​%=​取余赋值​a %= 3​等同于 a = a % 3​

示例代码： ​

csharp
int x = 10;
x += 5;  // x = 15
x *= 2;  // x = 30
x /= 3;  // x = 10

注意： ​

  • 复合赋值运算符可以使代码更加简洁，在计算的同时对变量进行赋值。

4. 比较运算符 ​

比较运算符用于比较两个值，并返回布尔值 true​ 或 false​。这些运算符常用于条件判断语句中。

运算符操作示例结果
​==​等于​5 == 5​​true​
​!=​不等于​5 != 3​​true​
​>​大于​10 > 3​​true​
​<​小于​2 < 5​​true​
​>=​大于等于​4 >= 4​​true​
​<=​小于等于​3 <= 4​​true​

示例代码： ​

csharp
int a = 10;
int b = 20;

bool isEqual = (a == b);  // false
bool isGreater = (a > b); // false
bool isLessOrEqual = (a <= b); // true

注意： ​

  • 比较运算符的结果始终是布尔值 true​ 或 false​，常用于 if-else​ 等控制结构中。

5. 逻辑运算符 ​

逻辑运算符用于操作布尔表达式，通常用于复杂条件的组合。

运算符操作示例结果
​&&​逻辑与​(a > 0) && (b > 0)​两个表达式都为 true​ 才返回 true​
​||​逻辑或​(a > 0) || (b > 0)​两个表达式有一个为 true​ 就返回 true​
​!​逻辑非​!(a > 0)​如果表达式为 true​，返回 false​

示例代码： ​

csharp
int a = 5;
int b = 10;

bool result = (a > 0) && (b > 0);  // true
bool result2 = (a < 0) || (b > 0); // true
bool result3 = !(a > 0);           // false

注意： ​

  • ​ ​​ ​&&​​​ ​：当两个条件都成立时，结果为 true​。
  • ​ ​​ ​||​​​ ​：当至少一个条件成立时，结果为 true​。
  • ​ ​​ ​!​​​ ​：对布尔表达式取反。

6. 位运算符 ​

位运算符用于对二进制位进行操作，通常用于底层编程或特定算法中。

运算符操作示例解释
​&​按位与​a & b​二进制位都为 1​ 时结果为 1​
``按位或`a
​^​按位异或​a ^ b​二进制位不同则结果为 1​
​~​按位取反​~a​对所有二进制位取反
​<<​左移​a << 2​将 a​ 的二进制位左移 2 位
​>>​右移​a >> 2​将 a​ 的二进制位右移 2 位

示例代码： ​

csharp
int a = 5;  // 二进制为 0101
int b = 3;  // 二进制为 0011

int result = a & b;  // result = 1 (0001)
int result2 = a | b; // result2 = 7 (0111)

7. 其他运算符 ​

  • 三元运算符 ​​ ​? :​​​ ​：用于简化 if-else​ 条件判断。

    csharp
    int a = 5;
string result = (a > 0) ? "正数" : "负数";

  • ​​​​is​​​​ 运算符：检查对象是否为某个类型。

    csharp
    if (obj is string) {
    Console.WriteLine("obj 是一个字符串");
}

  • ​​​​as​​​​ 运算符：尝试将对象转换为某个类型，转换失败则返回 null​。

    csharp
    object obj = "hello";
string str = obj as string;  // 如果 obj 不是字符串，str 将为 null

  • ​ ​​ ​??​​​ ​ 运算符：空合并运算符

  • ​ ​​ ​??​​​ ​ 运算符：空合并运算符用于返回第一个非空值，如果第一个操作数为 null​，则返回第二个操作数。

    csharp
    string name = null;
string displayName = name ?? "默认名称";  // 如果 name 为 null，则 displayName 为 "默认名称"

  • ​ ​​ ​?.​​​ ​ 运算符：空条件运算符用于在安全的情况下访问对象的成员或方法。如果对象为 null​，则整个表达式返回 null​，而不会引发 NullReferenceException​。

    csharp
    Person person = null;
string name = person?.Name;  // 如果 person 为 null，name 也将为 null

7. 运算符的优先级 ​

在表达式中，运算符的优先级决定了操作的执行顺序。优先级较高的运算符会优先执行。以下是常见运算符的优先级，从高到低排列：

优先级运算符描述
1​()​括号，强制优先计算
2​++​，--​自增，自减
3​!​，~​逻辑非，按位取反
4​*​，/​，%​乘法，除法，取余
5​+​，-​加法，减法
6​<<​，>>​左移，右移
7​<​，<=​，>​，>=​大小比较
8​==​，!=​等于，不等于
9​&​按位与
10​^​按位异或
11​!​逻辑非
12​&&​逻辑与
13​||​逻辑或
14​?:​三元运算符
15​=​，+=​，-=​ 等赋值及复合赋值
示例代码： ​
csharp
int result = 5 + 3 * 2;  // 结果为 11，因为乘法优先级高于加法

在上面的示例中，乘法 3 * 2​ 优先计算，结果为 6​，然后再进行加法 5 + 6​，最终结果为 11​。

使用括号来改变运算顺序： ​
csharp
int result = (5 + 3) * 2;  // 结果为 16，因为括号改变了优先级

8. 运算符的结合性 ​

当两个运算符的优先级相同时，结合性决定了运算顺序。运算符通常具有以下两种结合性：

  • 左结合：从左到右依次计算。大多数算术运算符和比较运算符都具有左结合性。

    csharp
    int result = 10 - 5 - 2;  // 从左到右依次计算，(10 - 5) - 2 = 3

  • 右结合：从右到左依次计算。赋值运算符具有右结合性。

    csharp
    int a, b, c;
a = b = c = 10;  // 从右到左依次赋值，先将 10 赋给 c，然后 c 的值赋给 b，最后 b 的值赋给 a

9. 运算符重载 ​

C# 允许在类或结构中重载某些运算符，使其可以用于类实例的运算操作。通过运算符重载，可以为自定义类型赋予更自然的语义。

示例代码： ​
csharp
class Complex
{
    public int Real { get; set; }
    public int Imaginary { get; set; }

    // 重载 + 运算符
    public static Complex operator +(Complex c1, Complex c2)
    {
        return new Complex { Real = c1.Real + c2.Real, Imaginary = c1.Imaginary + c2.Imaginary };
    }
}

Complex c1 = new Complex { Real = 1, Imaginary = 2 };
Complex c2 = new Complex { Real = 3, Imaginary = 4 };
Complex result = c1 + c2;  // 调用运算符重载，结果为 Real = 4, Imaginary = 6
注意： ​
  • 并不是所有运算符都可以重载，以下运算符是不能重载的：&&​、||​、? :​、=​、+=​、-=​ 等。
  • 重载运算符必须是 public static​ 方法。

总结 ​

C# 提供了丰富的运算符来满足各种编程需求，主要包括：

  • 算术运算符：用于基本的数学计算。
  • 赋值运算符：用于变量的赋值和复合赋值。
  • 比较运算符：用于比较两个值的关系。
  • 逻辑运算符：用于操作布尔值的逻辑运算。
  • 位运算符：用于对二进制位进行操作。
  • 三元运算符、空合并运算符、空条件运算符等特殊运算符，用于简化常见操作。
  • 优先级和结合性：决定了在复杂表达式中的运算顺序。
  • 运算符重载：可以自定义类的运算行为，增强代码的可读性。

理解和掌握这些运算符及其用法，是高效编写 C# 程序的基础。

‍

‍

‍

自增运算符和自减运算符详解 ​

在 C# 中，自增和自减运算符是对变量进行加一或减一的简化操作符。它们广泛应用于循环、计数器、条件判断等场景。根据操作符位置的不同，自增和自减运算符分为前置和后置，它们的行为有所不同。

1. 自增运算符 ++​ ​

自增运算符 ++​ 用于将变量的值增加 1。它有两种形式：

  • 前置自增：在变量前使用，表示先增加变量的值，然后再使用这个新值。
  • 后置自增：在变量后使用，表示先使用变量的当前值，然后再将其增加 1。
示例： ​
csharp
int a = 5;
int b = ++a;  // 前置自增：a 先加 1，a = 6，然后 b = 6

int c = 5;
int d = c++;  // 后置自增：d 先赋值为 c 当前的值，即 5，然后 c 自增 1，c = 6
运行结果： ​
csharp
a = 6, b = 6   // 前置自增，a 和 b 都是 6
c = 6, d = 5   // 后置自增，d 先是 5，c 然后变成 6

2. 自减运算符 --​ ​

自减运算符 --​ 用于将变量的值减少 1。它也有两种形式：

  • 前置自减：在变量前使用，表示先减少变量的值，然后再使用这个新值。
  • 后置自减：在变量后使用，表示先使用变量的当前值，然后再将其减少 1。
示例： ​
csharp
int a = 5;
int b = --a;  // 前置自减：a 先减 1，a = 4，然后 b = 4

int c = 5;
int d = c--;  // 后置自减：d 先赋值为 c 当前的值，即 5，然后 c 自减 1，c = 4
运行结果： ​
csharp
a = 4, b = 4   // 前置自减，a 和 b 都是 4
c = 4, d = 5   // 后置自减，d 先是 5，c 然后变成 4

3. 前置与后置的区别 ​

  • 前置自增/自减 (++a​ / --a​)：先对变量进行加一或减一操作，再返回新的值。
  • 后置自增/自减 (a++​ / a--​)：先返回当前值，再对变量进行加一或减一操作。
示例对比： ​
csharp
int a = 5;
Console.WriteLine(++a);  // 输出：6，先自增 a，然后输出 a 的新值

int b = 5;
Console.WriteLine(b++);  // 输出：5，先输出 b 的当前值，然后再自增 b，b = 6

在前置运算符中，变量的值在执行当前语句之前就被修改，而后置运算符则在执行完当前语句后才修改变量的值。这在复杂的表达式或循环中显得尤为重要。

4. 自增与自减运算符的常见用法 ​

自增和自减运算符常用于循环、计数、迭代等场景。

示例 1：使用自增运算符在循环中计数 ​
csharp
for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);  // 输出 0, 1, 2, 3, 4
}

在 for​ 循环中，i++​ 让 i​ 在每次循环后增加 1。

示例 2：使用自减运算符倒计时 ​
csharp
int countdown = 5;
while (countdown > 0)
{
    Console.WriteLine(countdown--);  // 输出 5, 4, 3, 2, 1
}

在这个例子中，countdown--​ 使得变量每次递减 1，直到循环条件不再成立。

5. 注意事项 ​

  • 自增运算符 ++​ 和自减运算符 --​ 只能用于变量，不能用于常量或表达式。例如，5++​ 或 (a + b)--​ 是无效的。
  • 选择前置或后置自增/自减运算符时，要根据需要的行为来决定。前置会立即改变变量的值，后置则会在当前表达式使用后再改变值。

总结 ​

  • 前置自增/自减 (++a​ / --a​)：先修改变量的值，再使用这个新值。
  • 后置自增/自减 (a++​ / a--​)：先使用变量的当前值，再修改变量的值。
  • 自增和自减运算符广泛应用于循环、迭代和计数器逻辑中。理解前置和后置的区别能帮助你更好地控制变量的变化顺序。

通过合理使用自增和自减运算符，可以使代码更简洁和高效。

Released under the MIT License.

Copyright © 2019-2025 Mr. Du