常量 const 定义
什么是常量
常量(constant)是用 const 关键字声明的、在编译期就确定值的绑定。和 let 变量不同,常量必须显式标注类型,不能使用类型推断;常量的值必须是编译期可计算的常量表达式,不能是运行时才能确定的值(比如函数调用的返回值、用户输入等)。
常量的命名规范是全大写字母加下划线分隔,比如 MAX_RETRY_COUNT、PI。这是 Rust 社区的约定,编译器也会在你不遵守时给出警告。
// 常量声明:const 名字: 类型 = 值;
// 必须标注类型,不能省略
const MAX_POINTS: u32 = 100_000;
// 常量可以在任何作用域声明,包括全局作用域
const PI: f64 = 3.141592653589793;
// 常量表达式可以包含基本运算
const HOURS_IN_DAY: u32 = 24;
const MINUTES_IN_HOUR: u32 = 60;
const SECONDS_IN_DAY: u32 = HOURS_IN_DAY * MINUTES_IN_HOUR * 60;
fn main() {
println!("最大积分:{}", MAX_POINTS);
println!("圆周率:{}", PI);
println!("一天的秒数:{}", SECONDS_IN_DAY);
}const 和 let 的区别
这是初学者最容易混淆的地方,两者看起来都是"给值取个名字",但本质差别很大。
| 对比项 | const | let |
|---|---|---|
| 可变性 | 永远不可变,不能加 mut | 默认不可变,可以加 mut |
| 类型标注 | 必须显式标注 | 可以省略(类型推断) |
| 值的来源 | 必须是编译期常量表达式 | 可以是运行时计算的值 |
| 作用域 | 可以在全局作用域声明 | 只能在函数/代码块内 |
| 遮蔽 | 不能被遮蔽(同一作用域) | 可以被遮蔽 |
| 内存表现 | 编译时内联到使用处,无固定内存地址 | 有确定的栈上内存位置 |
| 生命周期 | 整个程序运行期间有效 | 受所在作用域限制 |
const MAX: u32 = 100; // 编译期确定,全局有效
fn main() {
let x = get_value(); // 运行时确定
// const Y: u32 = get_value(); // 编译错误:不是常量表达式
println!("MAX = {}, x = {}", MAX, x);
}
fn get_value() -> u32 {
42
}常量表达式的限制
const 的值必须是编译期可以计算出来的,这意味着有些操作不能用在 const 定义中。
// 这些都是合法的常量表达式
const A: i32 = 10;
const B: i32 = A + 20; // 常量之间的运算
const C: f64 = 3.14 * 2.0; // 浮点运算
const D: bool = true; // 布尔值
const E: char = 'A'; // 字符
const F: &str = "hello"; // 字符串字面量
const G: [i32; 3] = [1, 2, 3]; // 数组(元素必须是常量)
const H: (i32, f64) = (1, 2.0); // 元组
// 这些不能用在 const 中
// const BAD1: String = String::from("hello"); // String::from 不是 const fn(在当前稳定版中)
// const BAD2: Vec<i32> = vec![1, 2, 3]; // vec! 宏涉及堆分配
// const BAD3: u32 = some_function(); // 普通函数不能在 const 中调用
fn main() {
println!("A={}, B={}, C={}", A, B, C);
println!("F={}, G={:?}", F, G);
}不过,标记为 const fn 的函数可以在常量表达式中调用:
// const fn 是可以在编译期求值的函数
const fn square(x: i32) -> i32 {
x * x
}
// 可以在 const 定义中调用 const fn
const SQUARED: i32 = square(5); // 25
// 标准库中很多方法已经是 const fn
// 比如整数的基本运算方法
const MAX_PLUS_ONE: u32 = u32::MAX.wrapping_add(1); // 0
fn main() {
println!("5 的平方:{}", SQUARED);
println!("u32::MAX + 1(wrapping):{}", MAX_PLUS_ONE);
}常量在不同作用域中的使用
// 全局常量:在整个 crate 中可见(如果是 pub 的话其他 crate 也可见)
const GLOBAL_TIMEOUT: u64 = 30;
mod config {
// 模块级常量:在 config 模块及其子模块中可见
pub const DEFAULT_PORT: u16 = 8080;
pub const DEFAULT_HOST: &str = "127.0.0.1";
}
fn main() {
// 函数内的常量:只在当前函数作用域内可见
const LOCAL_BUFFER_SIZE: usize = 1024;
println!("超时时间:{} 秒", GLOBAL_TIMEOUT);
println!("默认端口:{}", config::DEFAULT_PORT);
println!("默认主机:{}", config::DEFAULT_HOST);
println!("缓冲区大小:{}", LOCAL_BUFFER_SIZE);
}基本示例
一个使用常量的实际场景——游戏配置:
// 游戏相关的配置常量
const MAX_HEALTH: i32 = 100;
const MAX_MANA: i32 = 50;
const DAMAGE_PER_HIT: i32 = 15;
const HEAL_AMOUNT: i32 = 20;
const MANA_COST: i32 = 10;
// 用 const fn 计算派生常量
const fn hits_to_kill() -> i32 {
// 整数除法向下取整,所以需要判断是否有余数
if MAX_HEALTH % DAMAGE_PER_HIT == 0 {
MAX_HEALTH / DAMAGE_PER_HIT
} else {
MAX_HEALTH / DAMAGE_PER_HIT + 1
}
}
const HITS_TO_KILL: i32 = hits_to_kill();
fn main() {
let mut health = MAX_HEALTH;
let mut mana = MAX_MANA;
println!("初始状态:生命值 {}/{},魔法值 {}/{}",
health, MAX_HEALTH, mana, MAX_MANA);
println!("击杀所需次数:{}", HITS_TO_KILL);
// 模拟受到攻击
health -= DAMAGE_PER_HIT;
println!("受到 {} 点伤害,剩余生命值:{}", DAMAGE_PER_HIT, health);
// 模拟治疗
if mana >= MANA_COST {
health = (health + HEAL_AMOUNT).min(MAX_HEALTH);
mana -= MANA_COST;
println!("治疗 {} 点,生命值:{},魔法值:{}", HEAL_AMOUNT, health, mana);
}
}常见问题
问题一:什么时候用 const,什么时候用 let?
如果一个值在编译期就能确定,而且在整个程序运行期间不会变,就用 const。比如数学常数、配置参数、魔术数字(magic number)的命名等。如果值需要在运行时计算(比如从文件读取、用户输入、函数返回值),就用 let。
问题二:const 和 static 有什么区别?
两者都可以在全局作用域声明,但用途不同:
| 对比项 | const | static |
|---|---|---|
| 内存地址 | 没有固定地址,内联到使用处 | 有固定内存地址,整个程序共享一份 |
| 可变性 | 永远不可变 | 可以用 static mut(不安全) |
| 使用场景 | 编译期常量、配置值 | 全局状态、和 C 代码交互 |
| 引用 | 不能取引用(无地址) | 可以取引用 |
简单来说:能用 const 就用 const,只有需要固定内存地址的场景才用 static。
问题三:常量可以是复杂类型吗?
可以,但值必须是编译期可确定的。数组、元组、结构体(如果所有字段都是常量值)都可以。但像 String、Vec、HashMap 这些需要在运行时分配堆内存的类型不行。
问题四:为什么常量要求显式标注类型?
因为常量可以出现在全局作用域,编译器在处理它时可能还没有足够的上下文来推断类型。另外,显式标注类型也让常量的定义更加清晰明确,有利于代码阅读。
适用场景
- 消除魔术数字:把代码中散落的数字字面量提取为有意义的常量名
- 配置参数:超时时间、缓冲区大小、重试次数等不会在运行时变化的配置
- 数学/物理常数:圆周率、光速、重力加速度等
- 业务规则常量:最大密码长度、最小年龄限制、费率等
- 数组大小:
const BUFFER_SIZE: usize = 4096;然后用[u8; BUFFER_SIZE] - 跨模块共享的固定值:用
pub const导出给其他模块使用
注意事项
- 常量名必须使用 SCREAMING_SNAKE_CASE 风格(全大写 + 下划线),否则编译器会警告
- 常量必须显式标注类型,
const X = 5;会编译报错 - 常量不能使用
mut,const mut X: i32 = 5;语法不合法 - 常量的值在每个使用处都会被内联展开,大型数组常量可能增加编译产物体积
- 如果常量之间有依赖关系,被依赖的常量必须先定义(或至少在同一个作用域内)
const fn在 Rust 的各个版本中能力不断增强,以前不能在const fn中做的事现在可能已经可以了
总结
const 用于声明编译期确定的常量值,必须显式标注类型,值必须是常量表达式。常量没有固定内存地址,编译器会把常量值内联到每个使用的地方。常量可以在全局作用域、模块、函数内声明,命名规范是全大写加下划线。和 let 相比,const 的限制更多(不能 mut、不能运行时计算、必须标注类型),但它的优势是语义明确、性能无开销、可以在全局作用域使用。在实际编码中,把散落在代码各处的字面量提取为有意义的 const 常量,是提升代码可读性和可维护性的基本实践。