1
// C 语言中的典型错误
2
void use_after_free() {
3
    int* ptr = malloc(sizeof(int));
4
    *ptr = 42;
5
    free(ptr);
6

7
    // 错误：访问已释放的内存
8
    printf("%d\n", *ptr);  // 悬垂指针！
9
}
10

11
void memory_leak() {
12
    int* ptr = malloc(sizeof(int) * 1000);
13
    // 忘记 free(ptr)
14
    // 内存泄漏！
15
}
16

17
void double_free() {
18
    int* ptr = malloc(sizeof(int));
19
    free(ptr);
20
    free(ptr);  // 双重释放！
21
}

1
// Java 中的 GC 问题示例
2
public class GCIssue {
3
    public static void main(String[] args) {
4
        // 大量临时对象创建
5
        for (int i = 0; i < 1_000_000; i++) {
6
            String temp = new String("temporary " + i);
7
            // temp 很快变得不可达
8
            // 但要等 GC 运行才会回收
9
        }
10
        // GC 触发时可能导致明显停顿
11
    }
12
}

1
fn main() {
2
    // s 是字符串 "hello" 的所有者
3
    let s = String::from("hello");
4

5
    // s 离开作用域，内存自动释放
6
}

1
fn main() {
2
    let s1 = String::from("hello");
3
    let s2 = s1;  // 所有权从 s1 移动到 s2
4

5
    // println!("{}", s1);  // 错误！s1 已失效
6
    println!("{}", s2);     // 正确
7
}

1
fn main() {
2
    let s1 = String::from("hello");
3

4
    // 借用：s1 仍然拥有所有权
5
    let len = calculate_length(&s1);
6

7
    println!("'{}' 的长度是 {}", s1, len);  // s1 仍然可用
8
}
9

10
fn calculate_length(s: &String) -> usize {
11
    s.len()
12
    // s 是借用，离开作用域不会释放内存
13
}

1
fn main() {
2
    let mut s = String::from("hello");
3

4
    // 多个不可变借用
5
    let r1 = &s;
6
    let r2 = &s;
7
    println!("{} {}", r1, r2);
8

9
    // 可变借用（之前的不可变借用已结束）
10
    let r3 = &mut s;
11
    r3.push_str(" world");
12
    println!("{}", r3);
13

14
    // 错误示例：同时存在可变和不可变借用
15
    // let r4 = &s;
16
    // let r5 = &mut s;
17
    // println!("{} {}", r4, r5);  // 编译错误！
18
}

1
fn main() {
2
    let r;                  // ---------+-- 'a
3
                            //          |
4
    {                       //          |
5
        let x = 5;          // -+-- 'b  |
6
        r = &x;             //  |       |
7
    }                       // -+       |
8
                            //          |
9
    println!("r: {}", r);   // ---------+
10
}

1
error[E0597]: `x` does not live long enough
2
 --> src/main.rs:6:13
3
  |
4
6 |         r = &x;
5
  |             ^^ borrowed value does not live long enough
6
7 |     }
7
  |     - `x` dropped here while still borrowed
8
8 |
9
9 |     println!("r: {}", r);
10
  |                       - borrow later used here

1
fn main() {
2
    let s = String::from("hello");
3
    let ptr = &s;
4

5
    drop(s);  // 显式释放
6

7
    // println!("{}", ptr);  // 编译错误！
8
    // 借用检查器阻止了悬垂指针
9
}

1
use std::thread;
2

3
fn main() {
4
    let mut data = vec![1, 2, 3];
5

6
    let handle = thread::spawn(|| {
7
        // data.push(4);  // 编译错误！
8
        // 无法捕获可变引用
9
    });
10

11
    data.push(5);  // 主线程修改
12

13
    handle.join().unwrap();
14
}

1
fn main() {
2
    let mut s = String::from("hello");
3

4
    let r = &s;
5
    println!("{}", r);  // r 的最后一次使用
6

7
    // NLL：借用已结束，可以再次可变借用
8
    s.push_str(" world");  // 在 Rust 2018+ 中合法
9
    println!("{}", s);
10
}

1
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
2
    if x.len() > y.len() { x } else { y }
3
}

1
// 规则示例
2

3
// 1. 每个输入引用独立
4
fn foo(x: &i32, y: &i32);  // 实际是 fn foo<'a, 'b>(x: &'a i32, y: &'b i32)
5

6
// 2. 只有一个输入，输出同生命周期
7
fn foo(x: &str) -> &str;   // 实际是 fn foo<'a>(x: &'a str) -> &'a str
8

9
// 3. 有 &self 时，输出借用 self
10
struct Foo;
11
impl Foo {
12
    fn bar(&self, x: &str) -> &str;  // 输出借用 self
13
}

1
fn main() {
2
    let string1 = String::from("long string");
3

4
    {
5
        let string2 = String::from("short");
6
        let result = longest(string1.as_str(), string2.as_str());
7
        println!("最长的是: {}", result);
8
    }
9

10
    // println!("{}", result);  // 错误！result 的生命周期已结束
11
}
12

13
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
14
    if x.len() > y.len() { x } else { y }
15
}

1
// 结构体持有引用时必须标注生命周期
2
struct ImportantExcerpt<'a> {
3
    part: &'a str,
4
}
5

6
fn main() {
7
    let novel = String::from("Call me Ishmael. Some years ago...");
8
    let first_sentence = novel.split('.').next().unwrap();
9

10
    // first_sentence 借用 novel
11
    let excerpt = ImportantExcerpt {
12
        part: first_sentence,
13
    };
14

15
    println!("{}", excerpt.part);
16

17
    // excerpt 必须在 novel 之前离开作用域
18
}

1
#include <memory>
2
#include <iostream>
3

4
class Resource {
5
public:
6
    Resource() { std::cout << "Acquired\n"; }
7
    ~Resource() { std::cout << "Released\n"; }
8
};
9

10
void example() {
11
    // 正确使用智能指针
12
    std::unique_ptr<Resource> ptr = std::make_unique<Resource>();
13

14
    // 但这不是强制的！
15
    Resource* raw = new Resource();  // 可能忘记 delete
16
    // delete raw;  // 忘记释放？
17

18
    // 可能的问题
19
    std::unique_ptr<Resource> ptr2 = std::move(ptr);
20
    // ptr->doSomething();  // 运行时错误，不是编译错误
21
}

1
struct Resource;
2

3
impl Resource {
4
    fn new() -> Self {
5
        println!("Acquired");
6
        Resource
7
    }
8
}
9

10
impl Drop for Resource {
11
    fn drop(&mut self) {
12
        println!("Released");
13
    }
14
}
15

16
fn example() {
17
    let _r = Resource::new();  // 自动管理
18

19
    // let r2 = r;  // 移动后 r 失效
20
    // println!("{:?}", r);  // 编译错误！
21

22
    // 不可能忘记释放
23
    // 不可能双重释放
24
}

1
class Person {
2
    var name: String
3
    var friend: Person?  // 强引用，可能导致循环
4

5
    init(name: String) {
6
        self.name = name
7
        print("\(name) created")
8
    }
9

10
    deinit {
11
        print("\(name) deinitialized")
12
    }
13
}
14

15
func createCycle() {
16
    let alice = Person(name: "Alice")
17
    let bob = Person(name: "Bob")
18

19
    alice.friend = bob  // alice -> bob
20
    bob.friend = alice  // bob -> alice (循环引用！)
21
    // 内存泄漏！需要使用 weak var
22
}

1
use std::rc::Rc;
2
use std::cell::RefCell;
3

4
struct Person {
5
    name: String,
6
    friend: RefCell<Option<Rc<Person>>>,
7
}
8

9
impl Drop for Person {
10
    fn drop(&mut self) {
11
        println!("{} released", self.name);
12
    }
13
}
14

15
fn main() {
16
    let alice = Rc::new(Person {
17
        name: "Alice".to_string(),
18
        friend: RefCell::new(None),
19
    });
20

21
    let bob = Rc::new(Person {
22
        name: "Bob".to_string(),
23
        friend: RefCell::new(None),
24
    });
25

26
    // 循环引用会阻止释放
27
    *alice.friend.borrow_mut() = Some(bob.clone());
28
    *bob.friend.borrow_mut() = Some(alice.clone());
29
    // 需要使用 Weak<T> 打破循环
30
}

1
// 障碍一：理解移动语义
2
fn main() {
3
    let v = vec![1, 2, 3];
4
    let v2 = v;
5
    // println!("{:?}", v);  // 错误！v 已移动
6
}
7

8
// 障碍二：生命周期标注
9
fn first_word<'a>(s: &'a str) -> &'a str {
10
    let bytes = s.as_bytes();
11
    for (i, &item) in bytes.iter().enumerate() {
12
        if item == b' ' {
13
            return &s[0..i];
14
        }
15
    }
16
    &s[..]
17
}
18

19
// 障碍三：自引用结构
20
struct SelfRef {
21
    value: String,
22
    pointer: *const String,  // 原始指针绕过借用检查
23
    // 或者使用 Pin<Box<T>>
24
}

1
fn main() {
2
    let s = String::from("hello");
3
    let s1 = &s;
4
    let s2 = &mut s;
5
    println!("{} {}", s1, s2);
6
}

1
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
2
 --> src/main.rs:4:14
3
  |
4
3 |     let s1 = &s;
5
  |              -- immutable borrow occurs here
6
4 |     let s2 = &mut s;
7
  |              ^^^^^^ mutable borrow occurs here
8
5 |     println!("{} {}", s1, s2);
9
  |                       -- immutable borrow later used here

1
// Rust: 零成本抽象
2
fn sum_rust(data: &[i32]) -> i32 {
3
    data.iter().sum()  // 编译后与手写循环一样高效
4
}
5

6
// Java: 有 GC 开销
7
public int sumJava(int[] data) {
8
    int total = 0;
9
    for (int x : data) {
10
        total += x;
11
    }
12
    return total;
13
    // GC 可能在此期间运行
14
}

1
fn process_string(input: &str) -> String {
2
    let mut result = String::new();
3
    for word in input.split_whitespace() {
4
        if word.len() > 3 {
5
            result.push_str(word);
6
            result.push(' ');
7
        }
8
    }
9
    result.trim_end().to_string()
10
}
11

12
fn main() {
13
    let original = String::from("hello world from rust");
14

15
    // 借用 original，不获取所有权
16
    let processed = process_string(&original);
17

18
    println!("原始: {}", original);  // original 仍然可用
19
    println!("处理后: {}", processed);
20
}

1
use std::sync::{Arc, Mutex};
2
use std::thread;
3

4
fn main() {
5
    // Arc: 原子引用计数，允许多线程共享
6
    // Mutex: 互斥锁，保证安全访问
7
    let counter = Arc::new(Mutex::new(0));
8
    let mut handles = vec![];
9

10
    for _ in 0..10 {
11
        let counter = Arc::clone(&counter);
12
        let handle = thread::spawn(move || {
13
            let mut num = counter.lock().unwrap();
14
            *num += 1;
15
        });
16
        handles.push(handle);
17
    }
18

19
    for handle in handles {
20
        handle.join().unwrap();
21
    }
22

23
    println!("结果: {}", *counter.lock().unwrap());
24
}

1
// 简单的链表节点
2
pub struct List<T> {
3
    head: Link<T>,
4
}
5

6
type Link<T> = Option<Box<Node<T>>>;
7

8
struct Node<T> {
9
    elem: T,
10
    next: Link<T>,
11
}
12

13
impl<T> List<T> {
14
    pub fn new() -> Self {
15
        List { head: None }
16
    }
17

18
    pub fn push(&mut self, elem: T) {
19
        let new_node = Box::new(Node {
20
            elem,
21
            next: self.head.take(),
22
        });
23
        self.head = Some(new_node);
24
    }
25

26
    pub fn pop(&mut self) -> Option<T> {
27
        self.head.take().map(|node| {
28
            self.head = node.next;
29
            node.elem
30
        })
31
    }
32
}

1
fn main() {
2
    // 在堆上分配
3
    let b = Box::new(5);
4
    println!("b = {}", b);
5

6
    // 递归类型
7
    #[derive(Debug)]
8
    enum List<T> {
9
        Cons(T, Box<List<T>>),
10
        Nil,
11
    }
12

13
    let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
14
    println!("{:?}", list);
15
}

1
use std::rc::Rc;
2

3
fn main() {
4
    let a = Rc::new(5);
5
    let b = Rc::clone(&a);  // 引用计数 +1
6
    let c = Rc::clone(&a);  // 引用计数 +1
7

8
    println!("引用计数: {}", Rc::strong_count(&a));  // 3
9
}

1
use std::cell::RefCell;
2

3
fn main() {
4
    let x = RefCell::new(5);
5

6
    {
7
        let mut mutable = x.borrow_mut();
8
        *mutable += 1;
9
    }
10

11
    println!("{}", x.borrow());  // 6
12
}

1
// 高级抽象
2
let sum: i32 = (1..=100).sum();
3

4
// 编译后与手写循环一样高效
5
// 没有额外的运行时开销