Rust 运算符全面解析：从基础到实战

在 Rust 编程中，运算符是连接数据、实现逻辑的核心工具。它既包含 C 系语言的常见运算符，也提供了适配 Rust 安全语义的独特符号。掌握这些运算符，能让代码更简洁、执行更高效，同时加深对 Rust 核心机制的理解。

一、算术运算符：数值计算的基础

算术运算符用于执行基本的加减乘除等数值运算，需注意整数除法会直接舍弃小数部分，且 Rust 不支持 ** 或 ^ 作为乘方符号。

运算符	说明	示例	结果
+	加法	3 + 2	5
-	减法	8 - 2	6
*	乘法	3 * 2	6
/	除法（整数）	7 / 2	3
%	取余	7 % 2	1

关键补充：乘方运算

Rust 通过内置方法实现乘方，整数和浮点数需使用不同方法：

• 整数类型：使用 .pow(exp: u32) 方法，参数为无符号 32 位整数。
• 浮点类型：使用 .powf(exp: f64) 方法，参数支持小数。

代码示例：

fn main() {
    // 整数乘方：2^3
    let int_result = 2i32.pow(3);
    println!("2^3 = {}", int_result); // 输出：2^3 = 8

    // 浮点数乘方：2^2.5
    let float_result = 2.0f64.powf(2.5);
    println!("2^2.5 = {}", float_result); // 输出：2^2.5 = 5.656854249492381
}

二、关系运算符：判断数据的大小与相等性

关系运算符用于比较两个值的关系，结果始终为布尔类型（true 或 false），常用于条件判断（如 if、while）中。

运算符	说明	示例	结果
==	相等	5 == 5	true
!=	不相等	5 != 2	true
>	大于	5 > 2	true
<	小于	5 < 2	false
>=	大于等于	5 >= 5	true
<=	小于等于	2 <= 5	true

代码示例：

fn main() {
    let x = 5;
    let y = 10;

    println!("x == y : {}", x == y); // 输出：false
    println!("x != y : {}", x != y); // 输出：true
    println!("x < y  : {}", x < y);  // 输出：true
    println!("x >= y : {}", x >= y); // 输出：false
}

三、逻辑运算符：组合布尔值的逻辑判断

逻辑运算符用于连接多个布尔值，实现复杂逻辑判断，支持“短路求值”（即提前确定结果后，不再执行后续表达式）。

运算符	说明	示例	结果
&&	逻辑与（AND）	true && false	false
`		`	逻辑或（OR）
!	逻辑非（NOT）	!true	false

短路求值特性：

• &&：若左侧为 false，右侧表达式不再执行。
• ||：若左侧为 true，右侧表达式不再执行。

代码示例：

fn main() {
    let is_adult = true;
    let has_id = false;

    // 逻辑与：需同时满足才为 true
    println!("能否入场：{}", is_adult && has_id); // 输出：false

    // 逻辑非：取反布尔值
    println!("是否未成年：{}", !is_adult); // 输出：false
}

四、位运算符：直接操作二进制位

位运算符用于对整数的二进制位进行直接操作，常用于底层开发（如硬件控制、数据压缩），操作对象必须是整数类型。

运算符	说明	示例（二进制）	结果（二进制）
&	按位与	101（5） & 011（3）	001（1）
`	`	按位或	`101（5）
^	按位异或	101（5） ^ 011（3）	110（6）
!	按位取反	!101（5）	...11111010
<<	左移	101（5） << 1	1010（10）
>>	右移	101（5） >> 1	10（2）

代码示例：

fn main() {
    let x: u8 = 0b1010; // 二进制 1010，对应十进制 10
    let y: u8 = 0b1100; // 二进制 1100，对应十进制 12

    println!("x & y = {:b}", x & y); // 输出：1000
    println!("x << 1 = {:b}", x << 1); // 输出：10100（左移 1 位，相当于乘 2）
    println!("!x = {:b}", !x); // 输出：11110101（u8 类型，8 位补码）
}

五、赋值与复合赋值运算符：简化变量更新

赋值运算符用于给变量赋值，复合赋值运算符则将“运算+赋值”合并，简化代码书写，且仅能用于可变变量（mut 修饰）。

基础运算符	复合运算符	说明	示例	等价写法
=	-	直接赋值	x = 3	-
+	+=	加后赋值	x += 2	x = x + 2
-	-=	减后赋值	x -= 2	x = x - 2
*	*=	乘后赋值	x *= 2	x = x * 2
/	/=	除后赋值	x /= 2	x = x / 2
&	&=	按位与后赋值	x &= 2	x = x & 2
<<	<<=	左移后赋值	x <<= 1	x = x << 1

代码示例：

fn main() {
    let mut n = 5; // 必须用 mut 修饰，才能修改值

    n += 3; // 等价于 n = n + 3，结果为 8
    println!("n += 3 -> {}", n);

    n >>= 1; // 等价于 n = n >> 1，结果为 4
    println!("n >>= 1 -> {}", n);
}

六、其他常用运算符：适配 Rust 独特语义

除上述基础运算符外，Rust 还提供了多个适配其语言特性的运算符，覆盖范围生成、类型转换、错误处理等场景。

运算符	说明	示例	作用
..	左闭右开范围	0..5	生成 0、1、2、3、4（不含 5）
..=	全闭范围	0..=5	生成 0、1、2、3、4、5（含 5）
as	显式类型转换	5 as f32	将整数 5 转换为浮点数 5.0
?	错误传播	read_file()?	若 Result 为 Err，直接返回错误
*	解引用	*ptr	获取指针/引用指向的值
&	取引用	&x	创建变量 x 的不可变引用
ref	绑定为引用	let ref y = x	等价于 let y = &x

代码示例：

fn main() {
    // 1. 范围运算符：用于循环
    println!("左闭右开范围（1..4）：");
    for i in 1..4 {
        print!("{} ", i); // 输出：1 2 3
    }

    println!("\n全闭范围（1..=3）：");
    for i in 1..=3 {
        print!("{} ", i); // 输出：1 2 3
    }

    // 2. 类型转换与引用
    let a = 10i32;
    let b = a as f64; // 转换为浮点数
    let c = &a; // 取 a 的引用

    println!("\na = {}, b = {}, *c = {}", a, b, *c); // 输出：a = 10, b = 10.0, *c = 10
}

要不要我帮你整理一份 Rust 运算符速查表？包含所有运算符的分类、用法和示例，方便你日常开发时快速查阅。