1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 定义一个名为 Greeting 的 trait
// 翻译过来就是："所有自称会打招呼的类型，必须实现 say_hello 方法"
trait Greeting {
    // 方法签名：返回 String，没有参数
    // 这是抽象的，不提供默认实现
    fn say_hello(&self) -> String;

    // 还可以有更多方法签名...
    fn say_goodbye(&self) -> String;
}

1
2
3
4
5
6
7

// 再来一个更贴近生活的例子：Printable trait
// 任何想要被"打印"的东西，都得实现这个 trait
trait Printable {
    // 要求实现者提供一个 format 方法
    // 返回一个 String，这个 String 应该是格式化后的表示
    fn format(&self) -> String;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 让我们定义一个更复杂的 trait，包含各种"签名风格"
trait Animal {
    // 基础版：无参数，返回 String
    fn name(&self) -> String;

    // 进阶版：带参数，返回 bool
    // 这个方法检查某种食物是否喜欢
    fn likes_food(&self, food: &str) -> bool;

    // 高阶版：可变引用 self，可以修改内部状态
    fn rename(&mut self, new_name: String);

    // 终极版：不消耗 self，但也不返回任何东西
    fn make_sound(&self);

    // 独占版：消耗 self，这个 animal 之后就不能用了
    fn into_string(self) -> String where Self: Sized;
    // where Self: Sized 是默认约束，表示 self 有确定大小
    // 大部分时候你可以省略这个约束
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// 先定义一个 trait
trait Cookable {
    fn cook(&self) -> String;
}

// 再定义一个类型
struct Egg {
    // 鸡蛋的属性：新鲜程度，0-100
    freshness: u8,
}

// 关键语法：为 Egg 实现 Cookable trait
impl Cookable for Egg {
    // 实现具体的方法
    fn cook(&self) -> String {
        if self.freshness > 50 {
            format!("煎个荷包蛋，鲜度{}%，完美！", self.freshness)
        } else {
            format!("这蛋不太新鲜了({}%),还是做熟透了吧...", self.freshness)
        }
    }
}

fn main() {
    let my_egg = Egg { freshness: 85 };
    println!("{}", my_egg.cook());
    // 打印结果: 煎个荷包蛋，鲜度85%，完美！
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

// 定义一个 Describable trait
trait Describable {
    fn describe(&self) -> String;
}

// 定义几种类型
struct Water {
    temperature: f32,  // 水温，单位摄氏度
}

struct Coffee {
    strength: u8,      // 浓郁度，1-10
    caffeine_mg: u32,  // 咖啡因含量，毫克
}

// 为 Water 实现 Describable
impl Describable for Water {
    fn describe(&self) -> String {
        if self.temperature < 0.0 {
            "冰块警告！".to_string()
        } else if self.temperature < 30.0 {
            "凉白开，养生首选"
        } else if self.temperature < 60.0 {
            "温水，暖胃"
        } else {
            "热水，烫嘴预警"
        }.to_string()
    }
}

// 为 Coffee 实现 Describable
impl Describable for Coffee {
    fn describe(&self) -> String {
        format!(
            "咖啡：浓郁度{}级，咖啡因{}毫克，{}",
            self.strength,
            self.caffeine_mg,
            if self.caffeine_mg > 200 { "今晚别想睡了" } else { "还能接受" }
        )
    }
}

fn main() {
    let water = Water { temperature: 45.0 };
    let coffee = Coffee { strength: 7, caffeine_mg: 250 };

    println!("水: {}", water.describe());
    println!("咖啡: {}", coffee.describe());
    // 打印结果:
    // 水: 温水，暖胃
    // 咖啡: 咖啡因250毫克，今晚别想睡了
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// T: Greeting 是一个 trait 约束
// 意思是："T 必须实现了 Greeting 这个 trait"
fn print_greeting<T: Greeting>(item: &T) {
    // 这里编译器知道 T 一定实现了 say_hello
    // 所以可以直接调用
    println!("{}", item.say_hello());
}

// 也可以用 where 语法，代码更清晰
fn print_greeting_clean<T>(item: &T)
where
    T: Greeting,
{
    println!("{}", item.say_hello());
}

// 多个约束也是可以的
fn print_multiple<T>(item: &T)
where
    T: Greeting + Printable,
    // T 必须同时实现 Greeting 和 Printable
{
    println!("{}", item.format());
    println!("{}", item.say_hello());
}

// 实现一下 Greeting trait 先
struct Robot {
    name: String,
}

impl Greeting for Robot {
    fn say_hello(&self) -> String {
        format!("01011001，你好！我是机器人{}", self.name)
    }
    fn say_goodbye(&self) -> String {
        format!("再见，人类！{}下线了", self.name)
    }
}

fn main() {
    let robot = Robot { name: "R2-D2".to_string() };
    print_greeting(&robot);
    // 打印结果: 01011001，你好！我是机器人R2-D2
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// 定义一个带有默认实现的 trait
trait Discountable {
    // 这个方法没有默认实现，实现者必须自己写
    fn original_price(&self) -> f64;

    // 这个方法有默认实现！
    fn discounted_price(&self, discount: f64) -> f64 {
        // 默认逻辑：原价的 discount 折
        // 也就是说 discount=0.8 表示打八折
        self.original_price() * discount
    }

    // 再来一个默认方法：格式化输出价格
    fn price_tag(&self) -> String {
        format!("原价: {:.2}, 现价: {:.2}",
            self.original_price(),
            self.discounted_price(1.0))
    }
}

struct Product {
    name: String,
    price: f64,
}

impl Discountable for Product {
    // 必须实现 original_price
    fn original_price(&self) -> f64 {
        self.price
    }
    // discounted_price 和 price_tag 都使用默认实现
}

fn main() {
    let phone = Product {
        name: "iPhone 99".to_string(),
        price: 9999.0,
    };

    println!("{}", phone.price_tag());
    println!("七折后: {:.2}", phone.discounted_price(0.7));
    // 打印结果:
    // 原价: 9999.00, 现价: 9999.00
    // 七折后: 6999.30
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

trait Greeting {
    fn say(&self) -> String;
}

// 默认实现
trait FormalGreeting {
    fn say(&self) -> String {
        "你好，阁下".to_string()  // 默认版：正式但有点古板
    }
}

// VIPS顾客
struct VIPCustomer {
    name: String,
    level: u8,  // VIP等级，1-5
}

impl FormalGreeting for VIPCustomer {
    // 重写！VIP 要享受特殊待遇
    fn say(&self) -> String {
        match self.level {
            5 => format!("尊贵的钻石会员{}，欢迎回家！", self.name),
            4 => format!("亲爱的金卡会员{}，好久不见！", self.name),
            _ => format!("{}先生/女士，这边请~", self.name),
        }
    }
}

struct RegularCustomer {
    name: String,
}

impl FormalGreeting for RegularCustomer {
    // 普通顾客就用默认实现吧
}

fn main() {
    let vip = VIPCustomer { name: "马爸爸".to_string(), level: 5 };
    let regular = RegularCustomer { name: "张三".to_string() };

    println!("VIP: {}", vip.say());
    println!("普通人: {}", regular.say());
    // 打印结果:
    // VIP: 尊贵的钻石会员马爸爸，欢迎回家！
    // 普通人: 你好，阁下
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

trait Printable {
    fn format(&self) -> String {
        // 默认实现就是简单粗暴的 Debug 格式
        format!("{:?}", self)
    }

    fn print_it(&self) {
        // 这个默认方法会调用 format()
        println!("{}", self.format());
    }
}

struct Book {
    title: String,
    pages: u32,
}

impl Printable for Book {
    // 我们重写 format，但想保留 print_it 的默认行为
    fn format(&self) -> String {
        format!("《{}》共{}页", self.title, self.pages)
    }
}

fn main() {
    let book = Book {
        title: "Rust 权威指南".to_string(),
        pages: 666,
    };

    book.print_it();  // 这里的 print_it 还是用的默认实现
    // 打印结果: 《Rust 权威指南》共666页
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// 父 trait：基础能力
trait CanRead {
    fn read(&self) -> String;
}

// 子 trait：继承 CanRead，还要加一个写的能力
trait CanWrite: CanRead {
    fn write(&self, content: &str) -> String;
}

// 如果你想实现 CanWrite，你必须先实现 CanRead
struct Writer {
    name: String,
    articles_written: u32,
}

impl CanRead for Writer {
    fn read(&self) -> String {
        format!("{}正在阅读参考资料...", self.name)
    }
}

impl CanWrite for Writer {
    fn write(&self, content: &str) -> String {
        format!("{}正在撰写文章，内容: {}", self.name, content)
    }
}

fn main() {
    let writer = Writer {
        name: "小明".to_string(),
        articles_written: 10,
    };

    println!("{}", writer.read());
    println!("{}", writer.write("Rust真有趣！"));
    // 打印结果:
    // 小明正在阅读参考资料...
    // 小明正在撰写文章，内容: Rust真有趣！
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

// 继续上面的例子，加入更多层级
trait CanSpeak: CanRead {
    fn speak(&self) -> String;
}

// 顶级 trait：什么都会
trait CanTeach: CanWrite + CanSpeak {
    fn teach(&self) -> String;
}

// 普通讲师
struct Lecturer {
    name: String,
    field: String,
}

impl CanRead for Lecturer {
    fn read(&self) -> String {
        format!("{}在研究{}", self.name, self.field)
    }
}

impl CanSpeak for Lecturer {
    fn speak(&self) -> String {
        format!("{}开始讲课了！", self.name)
    }
}

impl CanWrite for Lecturer {
    fn write(&self, content: &str) -> String {
        format!("{}写了: {}", self.name, content)
    }
}

impl CanTeach for Lecturer {
    fn teach(&self) -> String {
        format!("{}开设了一门课: {}", self.name, self.field)
    }
}

// 使用时，约束要完整
fn teach_someone<T: CanTeach>(teacher: &T) {
    println!("{}", teacher.read());
    println!("{}", teacher.speak());
    println!("{}", teacher.write("教案"));
    println!("{}", teacher.teach());
}

fn main() {
    let lecturer = Lecturer {
        name: "王教授".to_string(),
        field: "Rust系统编程".to_string(),
    };
    teach_someone(&lecturer);
    // 打印结果:
    // 王教授在研究Rust系统编程
    // 王教授开始讲课了！
    // 王教授写了: 教案
    // 王教授开设了一门课: Rust系统编程
}

1
2
3

翻译成人话就是：
"你不能给别人的孩子（类型）穿别人的衣服（trait）"
"除非这个衣服是你自己做的，或者这个孩子是你亲生的"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 假设我们要给标准库的 Vec<String> 实现一个自定义 trait
// 因为 Vec 不是我们定义的，所以这会违反孤儿规则

// 错误示例（请不要尝试编译）：
// impl MyTrait for Vec<String> { ... }
// 错误: 只能为当前 crate 中定义的类型实现外部 crate 的 trait

// 但是我们可以这样：定义一个自己的类型，然后给它实现标准库的 trait
mod my_module {
    pub struct MyVec<T>(pub Vec<T>);  // 包装一下，就是"新类型"

    // 现在我们可以为 MyVec<T> 实现标准库的 trait 了
    impl<T: std::fmt::Debug> std::fmt::Debug for MyVec<T> {
        fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
            write!(f, "MyVec({:?})", self.0)
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// 标准库的 String
use std::fmt;

// 创建一个新类型包装 String
struct Username(String);

// 为我们的新类型实现 Display
impl fmt::Display for Username {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "[用户: {}]", self.0)
    }
}

// 还可以实现更多 trait...
impl Clone for Username {
    fn clone(&self) -> Self {
        Username(self.0.clone())
    }
}

fn main() {
    let name = Username("Rustacean".to_string());
    println!("{}", name);
    println!("克隆一个: {}", name.clone());
    // 打印结果:
    // [用户: Rustacean]
    // 克隆一个: [用户: Rustacean]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// 场景1：为自己的类型实现标准库的 trait ✓
trait Serializable {
    fn serialize(&self) -> String;
}

struct MyConfig {
    name: String,
    version: u32,
}

impl Serializable for MyConfig {
    fn serialize(&self) -> String {
        format!("{{\"name\": \"{}\", \"version\": {}}}", self.name, self.version)
    }
}

// 场景2：为标准库类型实现自己的 trait ✓
trait Printable {
    fn print(&self);
}

impl Printable for Vec<i32> {
    fn print(&self) {
        println!("Vec<i32>: {:?}", self);
    }
}

// 场景3：为标准库类型实现标准库的 trait ✗（不允许！）
// impl Display for Vec<i32> { ... }  // 错误！

// 场景4：为外部 crate 的类型实现外部 crate 的 trait ✗（不允许！）
// 假设 weixin 和 pay 都是外部 crate
// impl pay::Payment for weixin::WeChatPay { ... }  // 错误！

fn main() {
    let config = MyConfig {
        name: "MyApp".to_string(),
        version: 1,
    };
    println!("{}", config.serialize());
    // 打印结果: {"name": "MyApp", "version": 1}

    let numbers = vec![1, 2, 3];
    numbers.print();
    // 打印结果: Vec<i32>: [1, 2, 3]
}

1
2
3

pub trait Debug {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error>;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

fn main() {
    let number = 42;
    let text = "hello";
    let array = [1, 2, 3];

    // {:?} 是 Debug 格式
    println!("数字: {:?}", number);
    println!("文本: {:?}", text);
    println!("数组: {:?}", array);

    // {:#?} 是美化输出的 Debug 格式
    println!("数组(美化): {:#?}", array);
    // 打印结果:
    // 数字: 42
    // 文本: "hello"
    // 数组: [1, 2, 3]
    // 数组(美化): [
    //     1,
    //     2,
    //     3,
    // ]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#[derive(Debug)]  // 一行顶一百行
struct Point {
    x: i32,
    y: i32,
}

#[derive(Debug)]
enum Direction {
    North,
    South,
    East,
    West,
}

#[derive(Debug)]
struct Rectangle {
    top_left: Point,
    bottom_right: Point,
}

fn main() {
    let p = Point { x: 10, y: 20 };
    let d = Direction::North;
    let rect = Rectangle {
        top_left: Point { x: 0, y: 10 },
        bottom_right: Point { x: 10, y: 0 },
    };

    println!("点: {:?}", p);
    println!("方向: {:?}", d);
    println!("矩形: {:?}", rect);

    // 打印结果:
    // 点: Point { x: 10, y: 20 }
    // 方向: North
    // 矩形: Rectangle { top_left: Point { x: 0, y: 10 }, bottom_right: Point { x: 10, y: 0 } }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

use std::fmt;

// 手动实现 Debug
struct Person {
    name: String,
    age: u8,
    height: f64,
}

impl fmt::Debug for Person {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // debug_struct 创建一个结构体风格的调试输出
        // "Person" 是结构体名称
        f.debug_struct("Person")
            .field("name", &self.name)           // 字段名和值
            .field("age", &self.age)
            .field("height", &format!("{:.1}", self.height))  // 格式化一下
            .finish()                               // 结束，必须调用
    }
}

fn main() {
    let person = Person {
        name: "张三".to_string(),
        age: 28,
        height: 175.5,
    };

    println!("{:?}", person);
    // 打印结果: Person { name: "张三", age: 28, height: "175.5" }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#[derive(Debug)]
struct Company {
    name: String,
    employees: Vec<Employee>,
}

#[derive(Debug)]
struct Employee {
    name: String,
    salary: u32,
}

fn main() {
    let company = Company {
        name: "宇宙科技".to_string(),
        employees: vec![
            Employee { name: "张三".to_string(), salary: 30000 },
            Employee { name: "李四".to_string(), salary: 35000 },
        ],
    };

    println!("单行格式:");
    println!("{:?}", company);

    println!("\n多行格式:");
    println!("{:#?}", company);

    // 打印结果:
    // 单行格式:
    // Company { name: "宇宙科技", employees: [Employee { name: "张三", salary: 30000 }, Employee { name: "李四", salary: 35000 }] }
    //
    // 多行格式:
    // Company {
    //     name: "宇宙科技",
    //     employees: [
    //         Employee {
    //             name: "张三",
    //             salary: 30000,
    //         },
    //         Employee {
    //             name: "李四",
    //             salary: 35000,
    //         },
    //     ],
    // }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// 场景1：包含没有实现 Debug 的类型
struct CannotDerive {
    name: String,           // String 实现了 Debug，可以
    // data: Rc<RefCell<...>>,  // 如果 Rc 没实现 Debug，就不能 derive
}

// 场景2：包含裸指针
// struct WithRawPointer {
    // ptr: *const i32,  // 裸指针没有实现 Debug
// }

// 场景3：枚举的某些 variant 携带非 Debug 类型
// 这时需要手动实现，为不能 Debug 的字段写个替代品

use std::fmt;

struct PartialDebug;

impl fmt::Debug for PartialDebug {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "<non-debuggable data>")
    }
}

#[derive(Debug)]
struct MayHaveSecrets {
    name: String,
    // secret: PartialDebug,  // 用一个实现了 Debug 的占位
}

fn main() {
    let m = MayHaveSecrets {
        name: "秘密项目".to_string(),
    };
    println!("{:?}", m);
    // 打印结果: MayHaveSecrets { name: "秘密项目" }
}

1
2
3

pub trait Display {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error>;
}

1
2

// Display 的签名特点：没有 ? 标记，说明不能失败
// 实际上 Result<(), Error> 在成功时总是 Ok(())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

use std::fmt;

struct Money {
    amount: f64,
    currency: String,
}

impl fmt::Display for Money {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // 使用 write! 宏将格式化字符串写入 Formatter
        write!(f, "{:.2} {}", self.amount, self.currency)
    }
}

fn main() {
    let wallet = Money {
        amount: 1234.567,
        currency: "人民币".to_string(),
    };

    println!("余额: {}", wallet);
    // 打印结果: 余额: 1234.57 人民币
}

1
2
3
4
5
6
7
8
9

// 这是行不通的：
// #[derive(Display)]  // 错误！Display 不能 derive

// 你必须手写：
// impl Display for MyType {
//     fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
//         ...
//     }
// }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

use std::fmt;

struct Temperature {
    celsius: f64,
}

impl fmt::Display for Temperature {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}°C", self.celsius)
    }
}

fn main() {
    let temp = Temperature { celsius: 36.6 };

    // to_string 内部调用了 Display
    let s = temp.to_string();
    println!("字符串: {}", s);
    println!("字符串: {:?}", s);  // 这里 s 已经是 String 了

    // 也可以用 .to_string() 直接转换
    let s2 = temp.to_string();
    // 打印结果:
    // 字符串: 36.6°C
    // 字符串: "36.6°C"
}

1
2
3

pub trait Clone {
    fn clone(&self) -> Self;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#[derive(Clone, Debug)]
struct Book {
    title: String,        // String 实现了 Clone
    author: String,       // String 实现了 Clone
    pages: u32,          // u32 实现了 Clone
}

fn main() {
    let book1 = Book {
        title: "Rust 实战".to_string(),
        author: "老王".to_string(),
        pages: 520,
    };

    // clone 一个副本
    let book2 = book1.clone();

    println!("原件: {:?}", book1);  // book1 还能用！
    println!("克隆: {:?}", book2);
    // 打印结果:
    // 原件: Book { title: "Rust 实战", author: "老王", pages: 520 }
    // 克隆: Book { title: "Rust 实战", author: "老王", pages: 520 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#[derive(Clone, Debug)]
struct Classroom {
    name: String,          // 堆上的字符串
    students: Vec<String>, // 堆上的动态数组
}

fn main() {
    let class1 = Classroom {
        name: "CS101".to_string(),
        students: vec!["张三".to_string(), "李四".to_string()],
    };

    let class2 = class1.clone();

    // 修改克隆后的对象，不会影响原件
    // (如果是引用拷贝/浅拷贝，就会互相影响)

    println!("原件: {:?}", class1);
    println!("克隆: {:?}", class2);

    // 打印结果:
    // 原件: Classroom { name: "CS101", students: ["张三", "李四"] }
    // 克隆: Classroom { name: "CS101", students: ["张三", "李四"] }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#[derive(Clone, Debug)]
struct Password {
    plaintext: String,  // 假设这是敏感信息
    hash: String,
}

fn main() {
    let original = Password {
        plaintext: "123456".to_string(),
        hash: "e10adc3949ba59abbe56e057f20f883e".to_string(),
    };

    // clone 后原件还能用
    let backup = original.clone();

    // 但你有两个独立的 Password 对象了
    println!("原件: {:?}", original);
    println!("备份: {:?}", backup);

    // 打印结果:
    // 原件: Password { plaintext: "123456", hash: "e10adc3949ba59abbe56e057f20f883e" }
    // 备份: Password { plaintext: "123456", hash: "e10adc3949ba59abbe56e057f20f883e" }
}

1
2
3

pub trait Copy: Clone {}
// Copy 继承自 Clone
// 意思是：如果你想让你的类型是 Copy，它必须也是 Clone

1
2
3
4
5
6

类比理解：
- Copy 是"复印机"：一键自动复印，你感觉不到发生了什么
- Clone 是"手动复印"：你需要按复印键，而且可能要等久一点

如果一个类型可以"一键复印"（Copy），它当然也可以"手动复印"（Clone）。
但反过来不一定对：手动复印可以做到的事情（深拷贝复杂结构），一键复印可能做不到。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

✓ 可以 Copy 的类型：
  - 所有原始类型：i32, u64, f64, bool, char
  - 只包含 Copy 类型的数组和元组
  - 不可变借用 &T（只要 T 是 Copy）
  - 固定大小的数组（元素是 Copy）

✗ 不能 Copy 的类型：
  - String（堆分配）
  - Vec（堆分配）
  - Box<T>（堆分配）
  - 所有自定义 struct/enum（除非显式标记）
  - 闭包（可能捕获环境）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

fn main() {
    // 原始类型都是 Copy
    let a: i32 = 42;
    let b = a;  // 隐式复制，没有 move
    println!("a = {}, b = {}", a, b);  // a 还能用！

    let c: f64 = 3.14;
    let d = c;
    println!("c = {}, d = {}", c, d);  // c 还能用！

    // 数组（元素是 Copy）是 Copy
    let arr1 = [1, 2, 3];
    let arr2 = arr1;
    println!("arr1 = {:?}", arr1);  // arr1 还能用！

    // 元组（元素都是 Copy）是 Copy
    let tuple1 = (1, 2.0, 'a');
    let tuple2 = tuple1;
    println!("tuple1 = {:?}", tuple1);  // tuple1 还能用！

    // 打印结果:
    // a = 42, b = 42
    // c = 3.14, d = 3.14
    // arr1 = [1, 2, 3]
    // tuple1 = (1, 2.0, 'a')
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#[derive(Copy, Clone, Debug)]
struct Point {
    x: i32,
    y: i32,
}

#[derive(Copy, Clone, Debug)]
struct Color {
    r: u8,
    g: u8,
    b: u8,
}

#[derive(Copy, Clone, Debug)]
struct Pixel(Point, Color);  // 元组结构体，字段都是 Copy

fn main() {
    let p = Point { x: 10, y: 20 };
    let p2 = p;  // Copy，p 还能用
    println!("p = {:?}", p);
    println!("p2 = {:?}", p2);

    let px = Pixel(Point { x: 0, y: 0 }, Color { r: 255, g: 0, b: 0 });
    let px2 = px;  // Copy，px 还能用
    println!("px = {:?}", px);
    println!("px2 = {:?}", px2);

    // 打印结果:
    // p = Point { x: 10, y: 20 }
    // p2 = Point { x: 10, y: 20 }
    // px = Pixel(Point { x: 0, y: 0 }, Color { r: 255, g: 0, b: 0 })
    // px2 = Pixel(Point { x: 0, y: 0 }, Color { r: 255, g: 0, b: 0 })
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#[derive(Copy, Clone, Debug)]
struct Metric {
    value: f64,
}

fn double(x: Metric) -> Metric {
    Metric { value: x.value * 2.0 }
}

fn main() {
    let m = Metric { value: 42.0 };

    // 按值传参，m 被复制
    let result = double(m);

    // m 还在！因为 Metric 是 Copy
    println!("原始: {:?}", m);
    println!("翻倍: {:?}", result);

    // 打印结果:
    // 原始: Metric { value: 42.0 }
    // 翻倍: Metric { value: 84.0 }
}

1
2
3

pub trait Drop {
    fn drop(&mut self);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

struct Connection {
    ip: String,
    port: u16,
}

impl Drop for Connection {
    fn drop(&mut self) {
        // 当 Connection 离开作用域时，自动调用这里
        println!("关闭连接: {}:{}", self.ip, self.port);
    }
}

fn main() {
    let conn = Connection {
        ip: "192.168.1.1".to_string(),
        port: 8080,
    };

    println!("建立连接: {}:{}", conn.ip, conn.port);
    println!("使用连接...");

    // conn 在这里离开作用域，drop 被自动调用
    // 打印结果:
    // 建立连接: 192.168.1.1:8080
    // 使用连接...
    // 关闭连接: 192.168.1.1:8080
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

use std::mem::drop;

struct File {
    name: String,
}

impl Drop for File {
    fn drop(&mut self) {
        println!("文件 {} 被关闭", self.name);
    }
}

fn main() {
    let file = File { name: "data.txt".to_string() };
    println!("打开文件: {}", file.name);

    // 显式调用 drop，提前释放
    drop(file);

    println!("干点别的事情...");

    // 注意：file 已经不可用了，因为我们显式 drop 了
    // 打印结果:
    // 打开文件: data.txt
    // 文件 data.txt 被关闭
    // 干点别的事情...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

原因分析：
- Copy 的语义是"按位复制，之后两个值独立存在"
- Drop 的语义是"清理资源"

如果一个类型既是 Copy 又是 Drop：
1. 赋值时发生 Copy，比如 let b = a;
2. a 和 b 都存在
3. a 离开作用域，调用 Drop
4. b 也要离开作用域，再调用 Drop
5. 资源被释放两次！(use-after-free bug)

所以 Rust 禁止了这种组合。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 这个代码无法编译：
// #[derive(Copy, Clone)]
// struct BadExample {
//     data: String,  // String 不是 Copy，所以其实不会冲突
// }

// 但如果你试图让一个包含非 Copy 字段的类型变成 Copy，
// 编译器会拒绝：
// error: the trait `Copy` cannot be derived for structs containing non-`Copy` types

// Rust 的设计让你不会犯这个错误。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 正确的做法：选择 Clone 或 Drop
// 方案1：只要 Clone，不要 Copy
#[derive(Clone)]
struct CloneOnly {
    data: String,
}

// 方案2：Clone 和 Drop 都要
struct BothNeeded {
    resource: Vec<u8>,
}

impl Drop for BothNeeded {
    fn drop(&mut self) {
        println!("释放资源...");
    }
}

fn main() {
    let c = CloneOnly { data: "hello".to_string() };
    let c2 = c.clone();  // 显式克隆
    println!("c = {}, c2 = {}", c.data, c2.data);
}

1
2
3

pub trait Default {
    fn default() -> Self;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#[derive(Default, Debug)]
struct Config {
    host: String,        // String 默认是空字符串
    port: u16,           // u16 默认是 0
    max_connections: usize,  // usize 默认是 0
    debug_mode: bool,   // bool 默认是 false
}

fn main() {
    let default_config = Config::default();
    println!("默认配置: {:?}", default_config);
    // 打印结果: 默认配置: Config { host: "", port: 0, max_connections: 0, debug_mode: false }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#[derive(Default, Debug)]
struct Player {
    name: String,
    health: u32,
    level: u8,
    score: u64,
}

fn main() {
    // 方式1：直接调用
    let default_player = Player::default();
    println!("默认玩家: {:?}", default_player);

    // 方式2：struct update 语法，部分字段覆盖
    let hero = Player {
        name: "超级玛丽".to_string(),
        health: 100,
        ..Default::default()  // 其他字段用默认值
    };
    println!("英雄玩家: {:?}", hero);

    // 打印结果:
    // 默认玩家: Player { name: "", health: 0, level: 0, score: 0 }
    // 英雄玩家: Player { name: "超级玛丽", health: 100, level: 0, score: 0 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#[derive(Default, Debug)]
struct ServerConfig {
    ip: String,
    port: u16,
    workers: u32,
    timeout_secs: u64,
}

fn main() {
    // 开发环境配置
    let dev_config = ServerConfig {
        ip: "127.0.0.1".to_string(),
        port: 8080,
        ..Default::default()
    };

    // 生产环境配置
    let prod_config = ServerConfig {
        ip: "0.0.0.0".to_string(),
        port: 80,
        workers: 16,
        timeout_secs: 300,
        ..Default::default()
    };

    println!("开发环境: {:?}", dev_config);
    println!("生产环境: {:?}", prod_config);

    // 打印结果:
    // 开发环境: ServerConfig { ip: "127.0.0.1", port: 8080, workers: 0, timeout_secs: 0 }
    // 生产环境: ServerConfig { ip: "0.0.0.0", port: 80, workers: 16, timeout_secs: 300 }
}

1
2
3

pub trait From<T> {
    fn from(value: T) -> Self;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// 1. 从 String 到 String（其实不需要，但可以展示）
impl From<String> for String {
    fn from(s: String) -> String {
        s
    }
}

// 2. 从 &str 到 String
impl From<&str> for String {
    fn from(s: &str) -> String {
        String::from(s)
    }
}

// 3. 从 i32 到 f64
impl From<i32> for f64 {
    fn from(n: i32) -> f64 {
        n as f64
    }
}

// 4. 从数组到 Vec
impl From<[i32; 3]> for Vec<i32> {
    fn from(arr: [i32; 3]) -> Vec<i32> {
        vec![arr[0], arr[1], arr[2]]
    }
}

fn main() {
    // 使用 .into() 方法，Rust 会自动推断使用哪个 From 实现
    let s1: String = String::from("hello");
    let s2: String = "world".into();
    let n: f64 = 42.into();
    let v: Vec<i32> = [1, 2, 3].into();

    println!("s1 = {}", s1);
    println!("s2 = {}", s2);
    println!("n = {}", n);
    println!("v = {:?}", v);

    // 打印结果:
    // s1 = hello
    // s2 = world
    // n = 42
    // v = [1, 2, 3]
}