1
fn main() {
2
    let s1 = String::from("hello"); // s1 拥有堆上的 "hello"
3
    let s2 = s1;                    // 所有权 move 到 s2
4

5
    // println!("{}", s1);          // ❌ 编译错误：value borrowed here after move
6
    println!("{}", s2);             // ✅ 现在 s2 是所有者
7
}

1
#include <iostream>
2
#include <string>
3
#include <utility>
4

5
int main() {
6
    std::string s1 = "hello";
7
    std::string s2 = std::move(s1);    // 显式 move
8

9
    std::cout << s2 << "\n";           // ✅ s2 拥有 "hello"
10
    std::cout << "s1.size() = "
11
              << s1.size() << "\n";    // ⚠️ 合法，但值未定义
12
    return 0;
13
}

1
fn main() {
2
    let b: Box<i32> = Box::new(42);
3
    println!("{}", *b); // 解引用得到 42
4
} // b 离开作用域，堆上 i32 被释放

1
enum List {
2
    Cons(i32, Box<List>),
3
    Nil,
4
}
5

6
use List::{Cons, Nil};
7

8
fn main() {
9
    let list = Cons(1, Box::new(
10
                  Cons(2, Box::new(
11
                  Cons(3, Box::new(Nil))))));
12
    // 略
13
    let _ = list;
14
}

1
#include <memory>
2

3
struct Node {
4
    int value;
5
    std::unique_ptr<Node> next;
6
};
7

8
int main() {
9
    auto head = std::make_unique<Node>(Node{
10
        1, std::make_unique<Node>(Node{
11
            2, std::make_unique<Node>(Node{3, nullptr})
12
        })
13
    });
14
    return 0;
15
}

1
use std::rc::Rc;
2

3
fn main() {
4
    let a = Rc::new(String::from("shared"));
5
    println!("count = {}", Rc::strong_count(&a)); // 1
6

7
    let b = Rc::clone(&a); // 不是深拷贝，只是计数 +1
8
    println!("count = {}", Rc::strong_count(&a)); // 2
9

10
    {
11
        let c = Rc::clone(&a);
12
        println!("count = {}", Rc::strong_count(&a)); // 3
13
    } // c drop，计数 -1
14

15
    println!("count = {}", Rc::strong_count(&a)); // 2
16
} // a、b drop，计数 → 0，String 被释放

1
use std::sync::Arc;
2
use std::thread;
3

4
fn main() {
5
    let data = Arc::new(vec![1, 2, 3]);
6
    let mut handles = vec![];
7

8
    for i in 0..3 {
9
        let data = Arc::clone(&data);
10
        handles.push(thread::spawn(move || {
11
            println!("thread {} sees {:?}", i, data);
12
        }));
13
    }
14

15
    for h in handles { h.join().unwrap(); }
16
}

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

4
int main() {
5
    auto data = std::make_shared<std::vector<int>>(
6
        std::vector<int>{1, 2, 3});
7
    auto copy = data; // 计数 +1
8
    // 跨线程也是同样的 shared_ptr，因为它内部一直是原子计数
9
}

1
use std::cell::RefCell;
2
use std::rc::{Rc, Weak};
3

4
struct Node {
5
    value: i32,
6
    parent: RefCell<Weak<Node>>,        // 👈 弱引用，避免循环
7
    children: RefCell<Vec<Rc<Node>>>,   // 👈 强引用，父持有子
8
}
9

10
fn main() {
11
    let leaf = Rc::new(Node {
12
        value: 3,
13
        parent: RefCell::new(Weak::new()), // 暂时没父节点
14
        children: RefCell::new(vec![]),
15
    });
16

17
    let branch = Rc::new(Node {
18
        value: 5,
19
        parent: RefCell::new(Weak::new()),
20
        children: RefCell::new(vec![Rc::clone(&leaf)]), // 把 leaf 强持有
21
    });
22

23
    // leaf 用 Weak 指向 branch
24
    *leaf.parent.borrow_mut() = Rc::downgrade(&branch);
25

26
    // 通过 upgrade() 访问父节点
27
    println!(
28
        "leaf 的父节点 value = {}",
29
        leaf.parent.borrow().upgrade().unwrap().value
30
    );
31
}

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

4
struct Node {
5
    int value;
6
    std::weak_ptr<Node> parent;
7
    std::vector<std::shared_ptr<Node>> children;
8
};

1
use std::cell::RefCell;
2

3
struct Counter {
4
    count: RefCell<i32>, // 即使外部只持有 &Counter，内部也能改
5
}
6

7
impl Counter {
8
    fn increment(&self) {
9
        *self.count.borrow_mut() += 1; // 注意是 &self，不是 &mut self
10
    }
11

12
    fn get(&self) -> i32 {
13
        *self.count.borrow()
14
    }
15
}
16

17
fn main() {
18
    let c = Counter { count: RefCell::new(0) };
19
    c.increment();
20
    c.increment();
21
    c.increment();
22
    println!("{}", c.get()); // 3
23

24
    // 运行时借用冲突会 panic，而不是编译错误：
25
    let _b1 = c.count.borrow_mut();
26
    // let _b2 = c.count.borrow_mut(); // ⚠️ 运行时 panic: already borrowed
27
}

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

4
fn main() {
5
    let shared = Rc::new(RefCell::new(vec![1, 2, 3]));
6

7
    let a = Rc::clone(&shared);
8
    let b = Rc::clone(&shared);
9

10
    a.borrow_mut().push(4);
11
    b.borrow_mut().push(5);
12

13
    println!("{:?}", shared.borrow()); // [1, 2, 3, 4, 5]
14
}

1
#include <iostream>
2
#include <memory>
3
#include <string>
4
#include <vector>
5

6
struct TreeNode {
7
    std::string name;
8
    std::weak_ptr<TreeNode> parent;                 // 弱引用避免循环
9
    std::vector<std::shared_ptr<TreeNode>> children;
10
};
11

12
void add_child(const std::shared_ptr<TreeNode>& parent,
13
               const std::shared_ptr<TreeNode>& child) {
14
    child->parent = parent;
15
    parent->children.push_back(child);
16
}
17

18
int main() {
19
    auto root = std::make_shared<TreeNode>();
20
    root->name = "root";
21

22
    auto a = std::make_shared<TreeNode>();
23
    a->name = "A";
24
    add_child(root, a);
25

26
    auto b = std::make_shared<TreeNode>();
27
    b->name = "B";
28
    add_child(a, b);
29

30
    // 从 b 反向走到 root
31
    if (auto p = b->parent.lock()) {
32
        std::cout << "b 的父节点是 " << p->name << "\n";   // A
33
        if (auto pp = p->parent.lock()) {
34
            std::cout << "b 的祖父是 " << pp->name << "\n"; // root
35
        }
36
    }
37
}

1
use std::cell::RefCell;
2
use std::rc::{Rc, Weak};
3

4
struct TreeNode {
5
    name: String,
6
    parent: RefCell<Weak<TreeNode>>,      // 弱引用，避免循环
7
    children: RefCell<Vec<Rc<TreeNode>>>, // 父持有子（强引用）
8
}
9

10
impl TreeNode {
11
    fn new(name: &str) -> Rc<Self> {
12
        Rc::new(Self {
13
            name: name.to_string(),
14
            parent: RefCell::new(Weak::new()),
15
            children: RefCell::new(vec![]),
16
        })
17
    }
18
}
19

20
fn add_child(parent: &Rc<TreeNode>, child: &Rc<TreeNode>) {
21
    // 子节点记录父亲（弱引用）
22
    *child.parent.borrow_mut() = Rc::downgrade(parent);
23
    // 父节点持有子节点（强引用）
24
    parent.children.borrow_mut().push(Rc::clone(child));
25
}
26

27
fn main() {
28
    let root = TreeNode::new("root");
29
    let a = TreeNode::new("A");
30
    let b = TreeNode::new("B");
31

32
    add_child(&root, &a);
33
    add_child(&a, &b);
34

35
    // 从 b 反向走到 root
36
    if let Some(p) = b.parent.borrow().upgrade() {
37
        println!("b 的父节点是 {}", p.name);            // A
38
        if let Some(pp) = p.parent.borrow().upgrade() {
39
            println!("b 的祖父是 {}", pp.name);          // root
40
        }
41
    }
42
}