Rust 所有权与核心概念完整指南

1
let x = 5;        // 不可变（默认）
2
let mut y = 5;    // 可变
3
y = 10;           // ✅ 可以修改
4
// x = 10;        // ❌ 编译错误！

1
let mut s = String::from("hello");
2
let t = &mut s;  // 可变引用
3
t.push_str(" world");
4

5
// let u = &mut s;  // ❌ 不能同时有多个可变引用

1
let a = 5;              // 整数
2
let b = true;           // 布尔
3
let c = 'A';            // 字符
4
let d = [1, 2, 3];      // 数组（固定大小）
5
let e = (4, 5.6);       // 元组（固定大小）
6
let f = "hello";        // 字符串字面量（&str）

1
let s = String::from("hello");  // 字符串内容
2
let v = vec![1, 2, 3];          // 向量内容
3
let b = Box::new(42);           // Box 数据

1
let s = String::from("hello");

1
栈（Stack）              堆（Heap）
2
┌─────────────┐         ┌─────────────┐
3
│  s (指针)    │────────>│  "hello"    │
4
│  长度: 5     │         │   h e l l o │
5
│  容量: 5     │         └─────────────┘
6
└─────────────┘

1
let x = 5;              // 存储在栈上
2
let y = Box::new(5);    // 存储在堆上，栈上只存指针

1
let boxed = Box::new(42);

1
栈（Stack）              堆（Heap）
2
┌─────────────┐         ┌─────────────┐
3
│  boxed       │────────>│    42       │
4
│  (指针)      │         │  (实际数据)  │
5
└─────────────┘         └─────────────┘

1
let mut boxed = Box::new(vec![1, 2, 3]);
2
boxed.push(4);     // ✅ 自动解引用，直接使用
3
boxed[0] = 42;     // ✅ 自动解引用
4

5
// 特殊情况需要手动解引用
6
let mut b = Box::new(5);
7
*b = 10;           // ✅ 修改值需要 *

1
Vec<u8>     // 存储 u8 类型（无符号8位整数）
2
Vec<i32>    // 存储 i32 类型
3
Vec<String> // 存储 String 类型
4
Vec<f64>    // 存储 f64 类型

1
// Vec 本身在栈上占 24 字节
2
// 堆上数据 = 元素个数 × 每个元素大小
3

4
let v1: Vec<u8> = vec![0; 1000];   // 堆上占 1000 字节
5
let v2: Vec<i32> = vec![0; 1000];  // 堆上占 4000 字节

1
// Vec 的数据在堆上，不是栈上！
2
let huge_array = vec![0; 1000000];  // 数据在堆上
3

4
// 转移所有权只复制指针（高效）
5
let vec1 = vec![0; 1000000];
6
let vec2 = vec1;  // 只复制了3个字节（指针、长度、容量）
7
// vec1 不再可用
8

9
// clone 会复制所有数据（慢）
10
let vec3 = vec![0; 1000000];
11
let vec4 = vec3.clone();  // 复制了100万个元素

1
from enum import Enum
2
class Color(Enum):
3
    RED = 1
4
    GREEN = 2

1
enum Color {
2
    Red,
3
    Green,
4
    Blue,
5
}
6

7
enum Message {
8
    Quit,                       // 无数据
9
    Move { x: i32, y: i32 },    // 结构体数据
10
    Write(String),              // 单个数据
11
    ChangeColor(u8, u8, u8),    // 元组数据
12
}

1
enum List {
2
    Cons(i32, Box<List>),  // 变体1：包含值和下一个节点
3
    Nil,                   // 变体2：空链表
4
}
5

6
// 使用变体
7
let node = List::Cons(5, Box::new(List::Nil));

1
// 完整路径
2
let list = List::Cons(1, Box::new(List::Nil));
3

4
// 导入后简化
5
use List::{Cons, Nil};
6
let list = Cons(1, Box::new(Nil));

1
match small_data {
2
    Data::Small(vec) => println!("小数据：{:?}", vec),
3
    Data::Large(vec) => println!("大数据：长度 {}", vec.len()),
4
}

1
enum List {
2
    Cons(i32, Box<List>),  // 值 + 指向下一个节点的指针
3
    Nil,                   // 空
4
}
5

6
// 链表：1 -> 2 -> 3 -> Nil
7
// Cons(1, Cons(2, Cons(3, Nil)))

1
// 从尾部开始构建
2
let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
3

4
// 逐步构建
5
let tail = Cons(3, Box::new(Nil));
6
let mid = Cons(2, Box::new(tail));
7
let head = Cons(1, Box::new(mid));

1
// 使用标准库
2
use std::collections::LinkedList;
3
let mut list = LinkedList::new();
4
list.extend([1, 2, 3]);
5

6
// 使用 Vec（推荐！）
7
let list = vec![1, 2, 3];  // 90% 的情况用 Vec 就够了

1
// . 用于实例（已经创建的对象）
2
// :: 用于类型/模块（命名空间）

1
struct Person {
2
    name: String,
3
    age: u32,
4
}
5

6
impl Person {
7
    fn greet(&self) {
8
        println!("你好，我是{}", self.name);
9
    }
10
}
11

12
let p = Person { name: "Alice".to_string(), age: 30 };
13
p.greet();          // ✅ 调用实例方法
14
println!("{}", p.name);  // ✅ 访问实例字段

1
class Config:
2
    DEFAULT = 100  # 类属性（类似关联常量）
3

4
    def __init__(self, value):
5
        self.value = value  # 实例属性
6

7
print(Config.DEFAULT)        # 类属性访问
8
config = Config(42)
9
print(config.value)          # 实例属性访问

1
struct Config {
2
    value: i32,
3
}
4

5
impl Config {
6
    const DEFAULT: i32 = 100;  // 关联常量
7
}
8

9
println!("{}", Config::DEFAULT);  // :: 访问
10
let config = Config { value: 42 };
11
println!("{}", config.value);     // . 访问

1
// 1. 栈上的引用
2
let x = 42;
3
let r = &x;
4
println!("{}", *r);  // 解引用，拿到 42
5

6
// 2. 堆上的数据（Box）
7
let b = Box::new(100);
8
println!("{}", *b);  // 解引用，拿出 100

1
let mut boxed = Box::new(vec![1, 2, 3]);
2
boxed.push(4);        // ✅ 自动解引用
3
println!("{}", boxed[0]);  // ✅ 自动解引用

1
// 1. 修改 Box 的值
2
let mut b = Box::new(5);
3
*b = 10;  // ✅ 必须用 *
4

5
// 2. 取出所有权
6
let b = Box::new(String::from("hello"));
7
let s = *b;  // ✅ 取出堆上的 String
8

9
// 3. 自定义类型的访问
10
struct Point { x: i32, y: i32 }
11
let p = Box::new(Point { x: 1, y: 2 });
12
println!("{}", (*p).x);  // 可以，但 p.x 更常见