一种「更懒」的写法
上一篇我们学会了 let mut——变量终于可以改了。改的方式是直接赋值:x = 10;。
但如果你的目的是「在原有值上加减乘除」,每次都写 x = x + 5 就有点啰嗦。本章目标:
用
+=、-=这类简写来更新变量的值。
先别急着看简写,咱们先把 x = x + 5 这件事彻底搞清楚——它是理解一切的钥匙。
关键心智模型:x = x + 5 不是数学等式
看这段代码:
fn main() {
let mut x = 10;
x = x + 5;
println!("{}", x); // 15
}
x 同时出现在 = 的左右两边。这在数学上说不通——「x 等于 x + 5」怎么可能成立?但在编程里,它是赋值语句,含义是:
- 先算右边:此时
x是 10,所以x + 5= 15; - 再存回左边:把 15 写回变量
x; - 于是
x从 10 变成 15。
记住这句话:先算右边,再存回左边。 = 不是「等于」,而是「把右边的结果放进左边的盒子」。
这个模型一旦建立,后面所有简写都顺理成章。
+= 就是 x = x + 5 的简写
上面那行可以写得更短:
fn main() {
let mut x = 10;
x += 5;
println!("{}", x); // 15
}
x += 5 完全等价于 x = x + 5,只是少写了一遍 x。这类运算符叫复合赋值运算符(compound assignment)——把「运算」和「赋值」合并成一步。
全套复合赋值运算符
加减乘除、取余,都有对应的简写。一表打尽:
| 简写 | 等价于 | 含义 |
|---|---|---|
x += 5 | x = x + 5 | 加 5 |
x -= 5 | x = x - 5 | 减 5 |
x *= 5 | x = x * 5 | 乘 5 |
x /= 5 | x = x / 5 | 除 5 |
x %= 5 | x = x % 5 | 对 5 取余 |
看一个把它们串起来用的例子:
fn main() {
let mut a = 20;
a -= 3;
println!("20 - 3 = {}", a); // 17
a *= 2;
println!("17 * 2 = {}", a); // 34
a /= 4;
println!("34 / 4 = {}", a); // 8(整数除法!)
a %= 3;
println!("8 % 3 = {}", a); // 2
}
注意每一步都基于 a 当前的值——这是一条会「滚动更新」的链:20 → 17 → 34 → 8 → 2。
一个小提醒:别忘了 mut
使用任何复合赋值运算符的前提,是变量必须用 let mut 声明——因为这些操作本质上都是在修改变量。
let mut x = 10;
x += 5; // ✅
let y = 10;
y += 5; // ❌ 编译错误:cannot assign twice to immutable variable
这正好复用了上一篇的知识:编译器会拦下对不可变变量的修改。
扩展一:整数除法会「截断」
上面例子里有个容易被忽略的细节:
a /= 4; // 34 / 4 = 8,而不是 8.5
因为 a 是整数(i32),Rust 的整数除法会直接丢掉小数部分(向零截断),所以 34 / 4 得到 8,不是 8.5。%= 拿到的也就是整数除法的余数。
如果你需要小数,得让操作数是浮点类型:
fn main() {
let mut a = 34.0; // f64 浮点数
a /= 4.0;
println!("{}", a); // 8.5
}
对比一下:
| 表达式 | 类型 | 结果 |
|---|---|---|
34 / 4 | 整数 i32 | 8(截断) |
34.0 / 4.0 | 浮点 f64 | 8.5 |
这个坑在做平均值、百分比计算时特别常见——两个整数相除,结果往往不是你想要的小数。
扩展二:复合赋值不改变类型
复合赋值运算符要求运算结果的类型能赋回原变量,所以类型必须匹配:
let mut x = 10; // x 是 i32
x += 5; // ✅ 5 也是 i32
x += 2.5; // ❌ 编译错误:不能把浮点加到整数上
Rust 不会像某些语言那样偷偷帮你做隐式类型转换。想混用类型,必须自己显式转换:
let mut x = 10_i32;
x += 2.5_f64 as i32; // 显式转成 i32(注意这会截断成 2)
顺带一提,Rust 的默认整数类型是 i32,默认浮点类型是 f64——这也是为什么上面 x += 2.5 会报类型不匹配。
扩展三:位运算也有复合形式
除了算术运算,位运算符也有对应的复合赋值版本:
| 简写 | 等价于 |
|---|---|
x &= 5 | x = x & 5 |
x |= 5 | x = x | 5 |
x ^= 5 | x = x ^ 5 |
x <<= 1 | x = x << 1 |
x >>= 1 | x = x >> 1 |
它们在处理标志位(flags)、掩码时很常用:
fn main() {
let mut flags = 0b0000_0001u8;
flags |= 0b0000_0100; // 打开第 2 位
println!("{:08b}", flags); // 00000101
}
虽然本章只要求掌握五个算术版本,但知道这套规律后,遇到位运算简写也不会陌生。
注意:逻辑运算
&&、||没有复合形式(不存在&&=),因为它们涉及短路求值,语义不同。位运算的&=、|=则是普通运算,不存在短路。
扩展四:右侧只求值一次(一个微妙区别)
x += f() 和 x = x + f() 在绝大多数情况下结果一样,但有个细微差别:复合赋值的左侧表达式只求值一次。
对简单变量 x 来说没区别。但当左侧是带索引或解引用的表达式时,就有意义了:
let mut arr = [1, 2, 3];
let mut i = 0;
arr[i] += 5; // arr[i] 的位置只算一次
等价展开大致是「取出 arr[i]、加 5、写回 arr[i]」,索引表达式不会重复计算。这在涉及函数调用或复杂表达式时,能避免重复求值的副作用。对初学者来说知道有这回事即可,写简单变量时无需纠结。
扩展五:溢出也要注意
复合赋值同样受整数溢出的约束。在 debug 模式下,整数溢出会导致 panic:
fn main() {
let mut x: u8 = 250;
x += 10; // debug 模式下 panic:attempt to add with overflow
}
因为 u8 最大只能到 255,250 + 10 超范围了。release 模式下则会「回绕」(wrap around)成 4——这种差异正是 Rust 让人又爱又恨的地方。
需要明确控制溢出行为时,可以用标准库方法:
let mut x: u8 = 250;
x = x.wrapping_add(10); // 回绕:4
x = x.saturating_add(10); // 饱和:255
x = x.checked_add(10).unwrap(); // 溢出时返回 None
这部分在进阶内容里会详细讲,这里先埋个种子。
常见坑小结
| 坑 | 说明 | 正确做法 |
|---|---|---|
忘了 let mut | 修改不可变变量编译报错 | 声明时加 mut |
| 整数除法丢小数 | 34 / 4 == 8 | 需要小数就用浮点数 |
| 混用整数和浮点 | x += 2.5 类型不匹配 | 显式转换类型 |
以为有 &&= / ||= | 逻辑运算无复合形式 | 逻辑运算老老实实写完整 |
| 忽略溢出 | debug 下 panic | 用 wrapping_* / saturating_* |
小结
回到本章目标:用 +=、-= 等简写更新变量。
这一节我们掌握了:
x = x + 5的含义是先算右边、再存回左边,不是数学等式;+=、-=、*=、/=、%=分别是对应运算后赋值的简写;- 使用前提是变量用
let mut声明; - 整数除法会截断小数,
34 / 4是8不是8.5; - 复合赋值不改变类型,整数与浮点不能混用;
- 位运算也有
&=、|=等复合形式,但逻辑运算没有; - 注意整数溢出:debug panic、release 回绕。
到这里,Rust 的基础积木又添一块:条件判断、逻辑运算符、作用域、可变性、变量更新。下一站通常是循环(loop / while / for)——复合赋值会在计数器累加里大显身手,正好接得上。Happy coding with Rust! 🦀
参考资料: