《Rust编程入门》4.1 变量、常量与可变性

December 31, 2024

4.1 变量、常量与可变性

Rust 的变量系统结合了静态类型、所有权规则和强类型推断，提供了一种既高效又安全的变量管理方式。本节将详细讲解变量的声明与使用、常量与静态变量的区别，以及 Rust 独特的可变性概念。

4.1.1 变量的声明与使用

在 Rust 中，变量的声明通常使用关键字 let。默认情况下，Rust 中的变量是不可变的，这样的设计是为了增强程序的安全性和可预测性。

示例：不可变变量

1
2
3
4
5


fn main() {
    let x = 5;
    println!("x 的值是: {}", x);
    // x = 10; // 错误：尝试修改不可变变量
}

如果需要一个可修改的变量，可以通过 mut 关键字使变量变为可变的。

示例：可变变量

1
2
3
4
5
6


fn main() {
    let mut x = 5;
    println!("初始值: {}", x);
    x = 10;
    println!("修改后的值: {}", x);
}

特点：

默认不可变（immutable）是 Rust 安全性的基础。
可变变量（mutable）使用 mut 明确标注，提高代码的可读性。

4.1.2 常量

Rust 中的常量使用 const 关键字声明。与变量不同，常量的值在编译时就确定了，并且始终不可变。常量的名称通常使用全大写字母，以下划线分隔单词，以便与变量区分。

常量的特点：

必须显式标注类型。
声明周期贯穿整个程序运行。
常量不能使用 mut，始终不可变。

示例：声明常量

1
2
3
4
5
6
7


const PI: f64 = 3.141592653589793;
const MAX_SCORE: u32 = 100;

fn main() {
    println!("PI 的值是: {}", PI);
    println!("最大分数是: {}", MAX_SCORE);
}

使用场景：

表示全局固定值（如数学常数、程序配置）。

4.1.3 静态变量

Rust 提供了 static 关键字用于声明静态变量。与常量不同，静态变量的值存储在程序的固定内存位置，并且可以是可变的，但需要通过不安全代码（unsafe）进行修改。

静态变量的特点：

声明周期贯穿整个程序运行。
默认是不可变的，但可以通过 mut 标记为可变。
使用时需注意线程安全问题。

示例：声明静态变量

1
2
3
4
5


static GREETING: &str = "Hello, Rust!";

fn main() {
    println!("{}", GREETING);
}

示例：可变静态变量

1
2
3
4
5
6
7
8


static mut COUNTER: i32 = 0;

fn main() {
    unsafe {
        COUNTER += 1;
        println!("COUNTER 的值是: {}", COUNTER);
    }
}

注意：

修改静态变量需要使用 unsafe，以确保开发者明确处理潜在的并发问题。
尽量使用 const 或局部变量，减少静态变量的使用。

4.1.4 遮蔽（Shadowing）

Rust 提供了变量遮蔽（shadowing）的功能，即在同一作用域内，可以重新声明一个同名变量以隐藏原有变量。

示例：变量遮蔽

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


fn main() {
    let x = 5;
    println!("x 的值是: {}", x);

    let x = x + 1; // 遮蔽原有变量 x
    println!("遮蔽后的 x: {}", x);

    {
        let x = x * 2; // 在新作用域内遮蔽
        println!("新作用域内的 x: {}", x);
    }

    println!("离开作用域后 x 的值: {}", x);
}

变量遮蔽的优点：

避免频繁使用 mut。
允许在类型变化时重新定义变量。

4.1.5 小结

Rust 的变量、常量和静态变量设计体现了它对安全性和性能的关注：

默认不可变的变量提高了代码的可靠性。
常量和静态变量提供了便捷的全局值管理。
变量遮蔽允许灵活的局部变量处理。

在下一节中，我们将深入探讨 Rust 的数据类型和类型推断，理解 Rust 如何通过静态类型系统增强安全性和性能。