青少年编程与数学 02-019 Rust 编程基础 03课题、变量与可变性

一、使用多个文件（模块）
- 1. 创建包结构
- 2. 在 `main.rs` 中引入模块
- - - 示例：`main.rs`
- 3. 定义模块文件
- - - 示例：`module1.rs`
    - 示例：`module2.rs`
- 4. 定义子模块
- - - 示例：`submodule/mod.rs`
    - 示例：`submodule/subfunction.rs`
- 5. 使用模块
- - - 示例：`main.rs`
- 6. 包的结构和模块路径
- 7. 使用 `use` 语句简化路径
- - - 示例：`main.rs`
- 模块总结
二、常量
- 1. 常量的定义
- - - 示例：
- 2. 常量的特点
- 3. 常量的作用域
- - - 示例：
- 4. 常量的用途
- - - 示例：
- 5. 与变量的区别
- 6. 常量的限制
- - - 示例：
- 7. 常量的高级用法
- - - 示例：
- 常量总结
三、变量与可变性
- 1. 变量的声明与初始化
- 2. 默认不可变性
- 3. 可变性的作用
- - - 示例：不可变变量
    - 示例：可变变量
- 4. 变量的绑定与阴影
- 5. 可变性与函数参数
- 6. 可变性与并发安全
- - - 示例：并发中的可变性
- 7. 示例合并
- - 运行结果
- 8. 变量与可变性总结
总结

**摘要：**在 Rust 编程中，变量与可变性是核心概念之一。Rust 的设计哲学强调内存安全和并发安全，而变量的可变性规则是实现这些目标的重要机制。理解变量与可变性对于编写安全、高效的 Rust 代码至关重要。字面量、常量的应用虽然较为容易，但在编程过程也是必要知识。

**关键词：**常量、变量、可变性、安全、模块

一、使用多个文件（模块）

在 Rust 中，一个包（crate）可以包含多个源代码文件，而不仅仅是一个 main.rs 或 lib.rs 文件。通过合理组织代码结构，可以将功能拆分到多个文件中，提高代码的可读性和可维护性。以下是如何在一个包中使用多个源代码文件的方法。

1. 创建包结构

假设你正在创建一个二进制包（binary crate），其结构可以如下：

my_project/
├── Cargo.toml
├── src/
│   ├── main.rs
│   ├── module1.rs
│   ├── module2.rs
│   └── submodule/
│       ├── mod.rs
│       └── subfunction.rs

2. 在 `main.rs` 中引入模块

在 Rust 中，模块（module）是组织代码的基本单元。你可以在 main.rs 中使用 mod 关键字引入其他源代码文件。

示例：`main.rs`

// 引入同一目录下的模块
mod module1;
mod module2;

// 引入子模块
mod submodule;

fn main() {
    // 使用模块中的函数
    module1::function1();
    module2::function2();

    // 使用子模块中的函数
    submodule::subfunction::function3();
}

3. 定义模块文件

每个模块文件对应一个 .rs 文件。在模块文件中，你可以定义函数、结构体、枚举等。

示例：`module1.rs`

pub fn function1() {
    println!("This is function1 from module1");
}

示例：`module2.rs`

pub fn function2() {
    println!("This is function2 from module2");
}

4. 定义子模块

子模块可以进一步组织代码。在子模块目录中，必须有一个 mod.rs 文件，它作为子模块的入口。

示例：`submodule/mod.rs`

// 引入子模块中的文件
mod subfunction;

pub fn submodule_function() {
    println!("This is a function in submodule");
}

// 重新导出子模块中的函数
pub use subfunction::function3;

示例：`submodule/subfunction.rs`

pub fn function3() {
    println!("This is function3 from subfunction");
}

5. 使用模块

在 main.rs 中，你可以通过模块路径访问定义在其他文件中的函数或类型。

示例：`main.rs`

mod module1;
mod module2;
mod submodule;

fn main() {
    module1::function1(); // 调用 module1 中的函数
    module2::function2(); // 调用 module2 中的函数
    submodule::subfunction::function3(); // 调用 submodule/subfunction 中的函数
}

6. 包的结构和模块路径

Rust 使用文件系统结构来组织模块。模块路径由文件路径和 mod 关键字共同决定。以下是一些关键点：

每个 .rs 文件可以定义一个模块。
子模块目录需要包含一个 mod.rs 文件。
在父模块中使用 mod 关键字引入子模块。
使用 pub 关键字使模块、函数或类型对外可见。

7. 使用 `use` 语句简化路径

在代码中频繁使用长模块路径可能会使代码变得冗长。可以使用 use 语句将模块路径引入到当前作用域中。

示例：`main.rs`

mod module1;
mod module2;
mod submodule;

// 引入模块中的函数
use module1::function1;
use module2::function2;
use submodule::subfunction::function3;

fn main() {
    function1(); // 直接调用 function1
    function2(); // 直接调用 function2
    function3(); // 直接调用 function3
}

模块总结

通过合理组织代码结构，使用 mod 关键字引入模块，以及使用 use 语句简化路径，你可以在一个 Rust 包中使用多个源代码文件。这种方式不仅有助于代码的模块化，还可以提高代码的可读性和可维护性。

二、常量

在 Rust 中，常量是一种特殊的变量，它的值在程序运行期间不能被修改。常量在 Rust 中有其独特的用途和规则，以下是对 Rust 中常量的详细解析：

1. 常量的定义

在 Rust 中，常量使用 const 关键字定义。其基本语法如下：

const CONSTANT_NAME: Type = value;

CONSTANT_NAME：常量的名称，通常使用大写字母和下划线来分隔单词，以符合 Rust 的命名约定。
Type：常量的类型，必须明确指定。
value：常量的值，必须是一个编译时可知的值。

示例：

const MAX_POINTS: u32 = 100_000;

在这个例子中，MAX_POINTS 是一个常量，类型为 u32，值为 100_000。

2. 常量的特点

不可变性：常量的值在定义后不能被修改。如果尝试修改常量的值，编译器会报错。
编译时常量：常量的值必须在编译时确定，不能依赖于运行时的值。
全局可访问性：常量在定义后可以在整个程序范围内访问，不受作用域的限制。

3. 常量的作用域

常量的作用域取决于其定义的位置：

全局常量：如果常量定义在模块的顶层，它可以在整个模块及其子模块中访问。
局部常量：如果常量定义在函数或模块的内部，它只能在该作用域内访问。

示例：

const GLOBAL_CONSTANT: i32 = 42;

fn main() {
    const LOCAL_CONSTANT: i32 = 100;
    println!("Global constant: {}", GLOBAL_CONSTANT);
    println!("Local constant: {}", LOCAL_CONSTANT);
}

在这个例子中，GLOBAL_CONSTANT 是一个全局常量，可以在整个程序中访问；而 LOCAL_CONSTANT 是一个局部常量，只能在 main 函数中访问。

4. 常量的用途

常量在 Rust 中有多种用途，主要包括以下几点：

配置参数：用于定义程序的配置参数，这些参数在运行时不会改变。
数学常量：用于定义数学常量，如 PI、E 等。
固定值：用于定义一些固定的值，如数组的大小、枚举的值等。

示例：

const PI: f64 = 3.141592653589793;
const ARRAY_SIZE: usize = 10;

5. 与变量的区别

可变性：变量可以被修改，而常量不能被修改。
存储位置：变量的值存储在内存中，而常量的值通常存储在代码段中。
作用域：变量的作用域通常受限于其定义的位置，而常量的作用域更广泛。

6. 常量的限制

值必须是编译时可知的：常量的值必须在编译时确定，不能依赖于运行时的值。
不能使用函数返回值：不能将函数的返回值赋值给常量，因为函数的返回值是运行时确定的。

示例：

const fn calculate() -> i32 {
    42
}

const VALUE: i32 = calculate(); // 错误：不能在常量定义中调用函数

7. 常量的高级用法

常量泛型：Rust 支持在泛型中使用常量，这可以用于定义数组的大小或其他需要固定值的场景。
常量函数：Rust 允许定义常量函数，这些函数可以在编译时被调用。

示例：

const fn add(a: i32, b: i32) -> i32 {
    a + b
}

const RESULT: i32 = add(2, 3);

常量总结

常量在 Rust 中是一种重要的特性，它用于定义在程序运行期间不可变的值。常量具有不可变性、编译时确定性以及全局可访问性等特点。通过合理使用常量，可以提高代码的可读性和安全性。

三、变量与可变性

1. 变量的声明与初始化

在 Rust 中，变量的声明使用 let 关键字。变量在声明时必须初始化，不能声明一个未初始化的变量。

let x = 5; // 声明一个变量 x，并初始化为 5

2. 默认不可变性

Rust 中的变量默认是不可变的（immutable）。一旦变量被赋值，其值就不能再被改变。这种设计可以防止意外修改变量值，从而减少错误。

let x = 5;
x = 6; // 错误：不能重新赋值给不可变变量

如果需要修改变量的值，必须在声明时明确指定变量为可变的（mutable），使用 mut 关键字。

let mut x = 5; // 声明一个可变变量 x
x = 6; // 正确：可以重新赋值

3. 可变性的作用

可变性（mutability）是 Rust 中一个重要的概念，它允许开发者明确控制变量的修改行为。通过限制变量的可变性，Rust 编译器可以在编译时检查潜在的错误，从而提高代码的安全性和可维护性。

示例：不可变变量

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);

    // x = 6; // 错误：不能重新赋值给不可变变量
    println!("The value of x is: {}", x);
}

示例：可变变量

fn main() {
    let mut x = 5;
    println!("The value of x is: {}", x);

    x = 6;
    println!("The value of x is: {}", x);
}

4. 变量的绑定与阴影

Rust 允许使用相同的变量名重新声明变量，这种行为称为“阴影”（shadowing）。阴影可以用于在同一个作用域内重新绑定变量，而不会影响原始变量的不可变性。

pub fn f01() {
    let x = 5; // 第一次声明 x
    println!("The value of x is: {}", x);

    let x = x + 1; // 重新声明 x，创建一个新的变量
    println!("The value of x is: {}", x);

    let x = x * 2; // 再次重新声明 x
    println!("The value of x is: {}", x);
}

输出结果：
The value of x is: 5
The value of x is: 6
The value of x is: 12

在这个例子中，虽然变量名都是 x，但每次使用 let 重新声明时，都会创建一个新的变量，而不会改变之前的变量值。

5. 可变性与函数参数

在 Rust 中，函数参数默认也是不可变的。如果需要在函数内部修改参数值，必须显式地将参数声明为可变的。

pub fn f02() {
    let mut x = 5;
    println!("The value of x is: {}", x);

    change(&mut x); // 传递可变引用
    println!("The value of x is: {}", x);
}

fn change(x: &mut i32) {
    *x = 6; // 修改传入的可变引用
}

运行结果：
The value of x is: 5
The value of x is: 6

6. 可变性与并发安全

Rust 的可变性规则在并发编程中尤为重要。通过限制可变性，Rust 编译器可以确保在多线程环境中不会出现数据竞争问题。只有当变量被显式声明为可变时，才能对其进行修改，这使得 Rust 能够在编译时检查并发安全性。

示例：并发中的可变性

use std::thread;

fn main() {
    let mut data = 5;

    let handle = thread::spawn(move || {
        data = 6; // 错误：data 不是可变的
    });

    handle.join().unwrap();
}

为了在多线程中安全地修改变量，可以使用 Arc（原子引用计数）和 Mutex（互斥锁）等工具来管理共享数据。

use std::sync::{Arc, Mutex};
use std::thread;

pub fn f03() {
    let data = Arc::new(Mutex::new(5));

    let data_clone = Arc::clone(&data);
    let handle = thread::spawn(move || {
        let mut num = data_clone.lock().unwrap();
        *num = 6; // 正确：通过互斥锁修改数据
    });

    handle.join().unwrap();

    let num = data.lock().unwrap();
    println!("The value of data is: {}", *num);
}

运行结果：
The value of data is: 6

7. 示例合并

把上面三个示例代码放在不同模块中，使用一个主程序运行所有不同模块中的代码：

mod t01;
mod t02;
mod t03;

fn main() {
    println!("t01::f01()运行结果:");
    t01::f01();
    println!("t02::f02()运行结果:");
    t02::f02();
    println!("t03::f03()运行结果:");
    t03::f03();
}

运行结果

t01::f01()运行结果:
The value of x is: 5
The value of x is: 6
The value of x is: 12
t02::f02()运行结果:
The value of x is: 5
The value of x is: 6
t03::f03()运行结果:
The value of data is: 6