Rust 仿射类型（Affine Types）

        在 Rust 中，仿射类型（Affine Types） 是所有权系统的理论基础，它规定了每个值有且仅有一次使用机会。这与线性类型（必须恰好使用一次）有所不同，允许值未被使用就被丢弃。

Rust 中的仿射类型核心特征

1. 移动语义（Move Semantics）

fn consume(s: String) { /* ... */ }

let s1 = String::from("hello");
consume(s1);  // 所有权转移给函数
// println!("{}", s1);  // 错误！s1 已被消费（使用次数耗尽）

• 当值被移动（赋值、传参、返回）后，原始绑定失效

• 符合仿射类型"最多使用一次"的特性

    2. 禁止重复使用

let v = vec![1, 2, 3];
let v1 = v;  // 所有权转移
// let v2 = v;  // 错误！v 已被消费

    3. 允许未使用即丢弃

fn create_data() -> ExpensiveResource {
    ExpensiveResource::new() // 创建后未使用直接丢弃
} // 这里调用 drop（符合仿射类型规则）

与线性类型的区别

Rust 中的具体体现

1. 所有权转移

let s = "value".to_string();
let t = s;  // s 的"使用次数"耗尽

 2.Copy 类型的例外

let x = 42;
let y = x;  // 允许复制（因为 i32 实现 Copy）
let z = x;  // 仍然有效（不违反仿射规则）

• 实现 Copy 的类型不受仿射规则限制

    3. 作用域结束时的自动丢弃

{
    let file = File::open("foo.txt").unwrap(); 
    // 未显式关闭，但作用域结束自动 drop
} // 这里调用 drop()

编译器保障

Rust 编译器通过借用检查器静态验证：

1. 每个值最多被使用一次

2. 所有权转移后禁止访问

3. 自动插入 drop 调用处理未使用值

为什么采用仿射类型？

1. 安全资源管理
   避免重复释放或资源泄漏（如文件句柄）

2. 内存安全基础
   与借用规则协同防止悬垂指针：

let r;
{
    let x = 5;
    r = &x;  // 错误！x 将在作用域结束时被 drop
}
println!("{}", r);

1. 零成本抽象
   所有检查在编译期完成，无运行时开销

实践意义

// 安全的多线程传递
let data = Arc::new(Mutex::new(vec![1, 2, 3]));
let handle = thread::spawn(move || {  // 所有权移入线程
    data.lock().unwrap().push(4);
});
// 这里不能再用 data（所有权已转移）

        Rust 的仿射类型系统是其内存安全和并发安全的基石，通过编译时强制执行的"最多使用一次"规则，在保证安全性的同时维持了系统级语言的性能优势。