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

// 来感受一下 Rust 的魅力！
// 这段代码在编译时就保证了内存安全，运行时不需要任何额外的安全检查

fn main() {
    let s1 = String::from("hello"); // 创建一个 String
    let s2 = s1; // 所有权从这里转移到 s2

    // 编译错误！s1 已经无效了！
    // Rust 编译器会说："嘿，s1 已经把所有权交给 s2 了，你不能再用 s1 了！"
    // println!("{}", s1); // ❌ 编译报错！

    // ✅ s2 才是合法所有者
    println!("{}", s2); // hello
}

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

// 如果你想借用一下（不获取所有权）？用引用！
fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // & 表示借用，不获取所有权

    // ✅ s1 仍然有效！
    println!("'{}' 的长度是 {}", s1, len); // 'hello' 的长度是 5
}

fn calculate_length(s: &String) -> usize {
    s.len() // 返回长度，不消耗 s
}

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

// C 语言：程序员的噩梦
char *strdup(const char *s) {
    char *p = malloc(strlen(s) + 1); // 如果 malloc 失败了怎么办？
    if (p) {
        strcpy(p, s); // 复制字符串
    }
    return p; // 调用者需要 free，否则内存泄漏
}

// C++：智能指针好了一点，但还是可能翻车
#include <memory>
std::string* create_string() {
    return new std::string("hello"); // 谁负责 delete？
}

1
2
3
4
5
6
7
8
9

// Rust：让编译器替你操心
fn create_string() -> String {
    String::from("hello") // 创建就完事，出了作用域自动释放
}

fn main() {
    let s = create_string();
    println!("{}", s); // 函数返回后 s 会被自动清理
}

1
2
3
4
5
6
7

// Java：GC 可能会在关键时刻喊停！
public class MemoryGame {
    private String data; // 这个 data 可能在 GC 时被移动
    // ...
    // 突然，GC 来了："所有人停一下！我要打扫卫生！"
    // 你的程序: 😱 卡了 100ms！
}

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

// Go：goroutine 很棒，但...
func worker(ch <-chan int, done <-chan struct{}) {
    for {
        select {
        case <-ch:
            // 处理数据
        case <-done:
            return // 收到结束信号，正常退出
        }
    }
}
// 注意：goroutine 泄漏在 Go 中是真实存在的问题——
// 如果没人关闭 channel，也没发送结束信号，worker 可能永远阻塞。
// 好的实践是使用 context.Context 或显式的 done channel。
// Go 的 channel 操作（send/recv/close）由 runtime 保证线程安全，
// 不会因并发操作 channel 本身而产生 data race。
// 但如果通过 channel 传递指针或共享可变状态，
// 仍需开发者保证数据访问的同步，否则仍可能出现 data race。

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

// Rust：编译时就告诉你所有问题！
use std::thread;

fn worker(ch: &std::sync::mpsc::Receiver<i32>) {
    while let Ok(data) = ch.recv() { // recv 会阻塞直到有数据或 channel 关闭
        println!("收到数据: {}", data);
    }
}

fn main() {
    let (tx, rx) = std::sync::mpsc::channel();
    
    // 编译保证：所有权的借用检查让 data race 不可能存在！
    let handle = thread::spawn(move || { // move 关键字强制闭包获取所有权
        worker(&rx);
    });
    
    tx.send(42).unwrap();
    handle.join().unwrap();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Python：简单粗暴，但慢
def sum_numbers(n):
    total = 0
    for i in range(n):
        total += i
    return total


if __name__ == "__main__":
    result = sum_numbers(1_000_000_000)
    print(f"结果是: {result}")  # 如果 n 是 10 亿，那你就去喝杯咖啡吧 ☕

1
2
3
4
5
6
7
8
9

// Rust：同样的逻辑，快到飞起！
fn sum_numbers(n: i64) -> i64 {
    (0..n).sum() // 编译器和 CPU 一起优化，跑了！
}

fn main() {
    let result = sum_numbers(1_000_000_000);
    println!("结果是: {}", result); // 瞬间完成！
}

1
2
3
4
5
6
7
8

// 一个简单的系统级程序
use std::ptr;

unsafe {
    // 直接和硬件对话！这是 C 程序员的专属技能
    let null_ptr: *const i32 = ptr::null();
    // println!("{}", *null_ptr); // 注释掉这行，别真跑，会炸！
}

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

// 使用 Actix-web 框架创建一个 Web 服务
use actix_web::{web, App, HttpServer, HttpResponse};

async fn index() -> HttpResponse {
    HttpResponse::Ok().body("你好，Rust Web!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new().route("/", web::get().to(index))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

1
2
3
4
5

// 编译到 WASM 可以在浏览器里运行
#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

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

// 嵌入式 Rust 示例（需要在 Cargo.toml 添加相关依赖）
#![no_std]
#![no_main]

use panic_halt as _;

#[arduino_uno::entry]
fn main() -> ! {
    let peripherals = arduino_uno::Peripherals::take().unwrap();
    let mut pin = peripherals.PORTB.split().pb5.into_output();
    
    loop {
        pin.set_high().unwrap();
        arduino_uno::delay::delay_ms(1000);
        pin.set_low().unwrap();
        arduino_uno::delay::delay_ms(1000);
    }
}

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

// 一个简单的 CLI 工具
use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    
    if args.len() < 2 {
        eprintln!("用法: {} <名字>", args[0]);
        std::process::exit(1);
    }
    
    println!("你好，{}！欢迎来到 Rust 的世界！", args[1]);
}

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

// 使用 candle 库做简单的张量计算（示例）
use candle::{Tensor, Device};

fn main() -> candle::Result<()> {
    let device = Device::Cpu;
    
    // 从切片创建一维张量
    let t1 = Tensor::from_slice(&[1.0f32, 2.0, 3.0], &device)?;
    let t2 = Tensor::from_slice(&[4.0f32, 5.0, 6.0], &device)?;
    
    // 张量相加
    let sum = t1.add(&t2)?;
    
    println!("{:?}", sum); // Tensor dty=float32 [3] device=cpu [ 5. ,  7. ,  9. ]
    
    Ok(())
}

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

// Rust 2018 Edition 预览版（需要 nightly + feature flag）
#![feature(async_await)]

async fn get_answer() -> i32 {
    42
}

// 2018 年之前？不存在的！你只能这样写：
extern crate futures;

use futures::future::ok;

fn main() {
    let _ = ok::<i32, ()>(42);
}

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

// Rust 2021: 数组的 IntoIterator
fn main() {
    let arr = [1, 2, 3, 4, 5];
    
    // 以前要这样写
    for i in arr.iter() {
        println!("{}", i);
    }
    
    // Rust 2021 直接写
    for i in arr {
        println!("{}", i); // 1, 2, 3, 4, 5
    }
}

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

// Rust 2024: let 链语法
fn foo() -> bool {
    println!("foo 被调用");
    true
}

fn bar() -> bool {
    println!("bar 被调用");
    true
}

fn main() {
    // let 链：所有条件都为真才执行
    let x = 5;
    if let true = foo() && bar() && (x > 3) {
        println!("条件都满足了！");
    }
    // foo 被调用
    // bar 被调用
    // 条件都满足了！
}

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

// Rust 2024: gen 块（需要 #![feature(gen_blocks)]）
#![feature(gen_blocks)]

use std::ops::{Generator, GeneratorState};

fn simple_gen() -> impl Generator<Yield = (), Return = ()> + 'static {
    move || {
        println!("第一步");
        yield;
        println!("第二步");
        yield;
        println!("第三步");
    }
}

fn main() {
    let mut gen = simple_gen();
    // 调用 resume() 来驱动生成器（GeneratorState::Yielded 表示暂停点）
    // 注：gen 块的 API 可能随 nightly 版本变化，以上代码仅供参考
    match gen.resume() {
        GeneratorState::Yielded(_) => println!("暂停在 yield 点"),
        GeneratorState::Complete(()) => println!("生成器结束"),
    }
}

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

// Rust 2024: let 链
fn process_data(data: Option<Vec<i32>>) {
    // 以前要嵌套 match 或 if let
    // 现在可以直接写 let 链
    if let Some(nums) = data && !nums.is_empty() && nums.len() > 5 {
        println!("数据长度: {}", nums.len());
    }
}

fn main() {
    process_data(Some(vec![1, 2, 3, 4, 5, 6, 7])); // 数据长度: 7
    process_data(Some(vec![1, 2])); // 什么都不输出
    process_data(None); // 什么都不输出
}

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

// Rust 2024: unsafe extern blocks 更安全
unsafe extern "C" {
    // 编译器会检查函数签名！
    fn c_function(x: i32) -> i32;
}

fn main() {
    unsafe {
        let result = c_function(42);
        println!("C 函数返回: {}", result);
    }
}

1
2
3
4
5
6
7
8
9

// 类型级数字的概念（需要 nightly Rust）
#![feature(generic_const_exprs)]

struct ArrayWrapper<const N: usize>([u8; N]);

fn main() {
    let wrapper = ArrayWrapper([0u8; 16]); // 编译保证长度是 16！
    println!("数组长度: {}", wrapper.0.len()); // 数组长度: 16
}

1
2
3
4
5
6

// Rust 编译器错误信息越来越友好了！
fn main() {
    let x = 5;
    // x = 6; // 试试取消这行注释，编译器会告诉你怎么改！
    println!("{}", x);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// Rust 的文档测试文化：文档里的代码示例会自动运行！
/// 将两个数字相加
///
/// # Examples
///
/// ```
/// assert_eq!(add(2, 3), 5);
/// ```
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

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

// burn 示例：创建一个简单的线性层（简化示例）
use burn::nn::Linear;
use burn::tensor::Tensor;

// 定义模型结构
pub struct MyModel {
    linear: Linear,
}

impl MyModel {
    // 注意：burn 0.13+ 的 Linear::new 直接接收维度参数
    pub fn new(input_features: usize, output_features: usize) -> Self {
        MyModel {
            linear: Linear::new(input_features, output_features),
        }
    }

    pub fn forward(&self, x: Tensor) -> Tensor {
        x.matmul(self.linear.weight()) + self.linear.bias()
    }
}

// 注意：burn 生态发展迅速，API 可能随版本变化
// 实际使用时请参考最新官方文档

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

// candle 示例：矩阵运算
use candle::{Tensor, DType, Device};

fn main() -> candle::Result<()> {
    let device = Device::Cpu;
    
    // 创建矩阵
    let a = Tensor::randn(0.0, 1.0, [3, 4], &device, DType::F32)?;
    let b = Tensor::randn(0.0, 1.0, [4, 2], &device, DType::F32)?;
    
    // 矩阵乘法
    let c = a.matmul(&b)?;
    
    println!("输出形状: {:?}", c.shape()); // [3, 2]
    
    Ok(())
}

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

// 使用 candle-transformers 运行 GPT-2 模型（简化示例）
//
// candle-transformers 加载 GPT-2 大致步骤：
// 1. 创建 Device (Cpu 或 Cuda)
// 2. 加载 Config 和模型权重 (Gpt2::load)
// 3. 加载 Tokenizer
// 4. 对输入文本进行 tokenize
// 5. 调用 model.generate() 生成文本
//
// 由于需要下载预训练权重（约 500MB），此处不做完整演示
// 感兴趣的读者可以参考 candle-transformers 官方 examples：
// https://github.com/huggingface/candle/blob/main/candle-examples/examples/yarn-llama2/main.rs

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

fn main() {
    // 基本的变量声明
    let x = 42; // x 是 i32 类型，值是 42
    println!("x = {}", x); // x = 42
    
    // 显式类型标注（有时候编译器需要你告诉它类型）
    let y: i64 = 1_000_000_000; // 用下划线分隔数字，更易读！
    println!("y = {}", y); // y = 1000000000
    
    // 字符串变量
    let name = "Rust";
    println!("你好，{}！", name); // 你好，Rust！
}

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

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    
    // 假设这是一个很长的函数...
    let first = numbers.get(0);
    let second = numbers.get(1);
    
    // 某个程序员（可能是三个月后的你）在这里偷偷改了 numbers
    // numbers = vec![1, 2]; // 天哪！
    
    // 你以为 first 和 second 还是原来的值，结果...
    println!("第一个: {:?}", first); // 可能不是你预期的了！
}

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

use std::thread;

fn main() {
    let data = vec![1, 2, 3]; // 不可变数据
    
    // 线程1：读取 data
    let handle1 = thread::spawn(move || {
        println!("线程1 看到的数据: {:?}", data);
        // data.push(4); // 编译错误！data 是不可变的！
    });
    
    // 线程2：读取 data
    let handle2 = thread::spawn(move || {
        // 线程2 也可以安全地读取，因为没人能改它
        // data 是 Copy 类型，所以可以复制一份给线程
    });
    
    handle1.join().unwrap();
    handle2.join().unwrap();
}

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

fn main() {
    let mut counter = 0; // 加了 mut，就可以改变了！
    
    println!("计数器初始值: {}", counter); // 计数器初始值: 0
    
    counter = counter + 1; // 修改它！
    println!("计数器加1后: {}", counter); // 计数器加1后: 1
    
    // 翻倍！
    counter = counter * 2;
    println!("计数器翻倍后: {}", counter); // 计数器翻倍后: 2
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

fn main() {
    let x = 10;
    // x = 20; // 编译错误！x 是不可变的！
    
    let mut y = 10;
    y = 20; // ✅ 没问题！y 是 mut
    
    let z = 30;
    y = z; // ✅ 没问题！都是 i32 类型，y 是 mut 的
    // 注意：y = z 能通过是因为 y 是 mut，跟 z 是多少没关系
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 常量必须标注类型！
const MAX_SIZE: usize = 100;
const PI: f64 = 3.141592653589793;
const GREETING: &str = "你好，Rust！";

fn main() {
    println!("最大尺寸: {}", MAX_SIZE); // 最大尺寸: 100
    println!("圆周率: {:.10}", PI); // 圆周率: 3.1415926535
    println!("{}", GREETING); // 你好，Rust！
}

1
2
3
4
5
6
7
8
9

fn main() {
    // const 可以在任何作用域，包括全局
    const LEVEL: i32 = 99;
    
    let level = 100;
    if level > LEVEL {
        println!("升级了！"); // 升级了！
    }
}

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

static mut COUNTER: i32 = 0;

fn increment() {
    unsafe {
        // 裸指针赋值，不创建引用，符合新版规则
        *&raw mut COUNTER += 1;
    }
}

fn main() {
    increment();
    increment();

    unsafe {       
        // println!("计数器值: {}", COUNTER);  // 会隐式创建 &i32 共享引用；
        // Rust 2024 认为：可变静态变量 + 共享引用 = 未定义行为（多线程下会数据竞争）。
        // 裸指针读取
        println!("计数器值: {}", *&raw const COUNTER);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

use std::sync::Mutex;

static COUNTER: Mutex<i32> = Mutex::new(0);

fn main() {
    *COUNTER.lock().unwrap() += 1;
    *COUNTER.lock().unwrap() += 1;
    
    println!("计数器: {}", *COUNTER.lock().unwrap()); // 计数器: 2
}

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

fn main() {
    let x = 5;
    println!("x = {}", x); // x = 5
    
    let x = x + 1; // 新的 x 遮蔽了旧的 x
    println!("x = {}", x); // x = 6
    
    let x = x * 2;
    println!("x = {}", x); // x = 12
    
    // 类型也可以变！
    let spaces = "   "; // 字符串
    let spaces = spaces.len(); // 变成了 usize！
    println!("空格数: {}", spaces); // 空格数: 3
}

1
2
3
4
5
6
7
8

fn main() {
    let mut s = String::from("hello");
    s = String::from("world"); // ✅ 可以，因为 s 是可变的
    
    let s = String::from("hello");
    let s = String::from("world"); // ✅ 也可以，但这是遮蔽
    // 区别：第一个 s 被销毁了，不是因为它可变
}

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

fn main() {
    // 场景1：类型转换
    let value = "42";
    let value: i32 = value.parse().unwrap();
    let value: f64 = value as f64;
    println!("最终值: {}", value); // 最终值: 42
    
    // 场景2：作用域内的重定义
    let x = 10;
    println!("外层 x = {}", x); // 外层 x = 10
    
    {
        let x = 20; // 这里是新的 x
        println!("内层 x = {}", x); // 内层 x = 20
    }
    
    println!("外层 x = {}", x); // 外层 x = 10
}

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

fn main() {
    // 多重赋值
    let (a, b) = (1, 2);
    println!("a = {}, b = {}", a, b); // a = 1, b = 2
    
    // 解构元组
    let (name, age, score) = ("小明", 25, 98.5);
    println!("{} 今年 {} 岁，成绩是 {}", name, age, score);
    // 小明 今年 25 岁，成绩是 98.5
    
    // 解构数组
    let [first, second, third] = [1, 2, 3];
    println!("{}, {}, {}", first, second, third); // 1, 2, 3
    
    // 解构嵌套
    let ((x1, y1), (x2, y2)) = ((1, 2), (3, 4));
    println!("({}, {}) 和 ({}, {})", x1, y1, x2, y2); // (1, 2) 和 (3, 4)
}

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

fn min_max(numbers: &[i32]) -> (i32, i32) {
    let min = *numbers.iter().min().unwrap();
    let max = *numbers.iter().max().unwrap();
    (min, max)
}

fn main() {
    let data = vec![3, 1, 4, 1, 5, 9, 2, 6];
    let (min, max) = min_max(&data);
    
    println!("最小值: {}, 最大值: {}", min, max); // 最小值: 1, 最大值: 9
}

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

fn get_length(s: Option<String>) -> usize {
    // 以前要这样写：
    // if let Some(s) = s {
    //     s.len()
    // } else {
    //     0
    // }
    
    // Rust 2024: let 链！
    let Some(s) = s else {
        return 0;
    };
    
    s.len()
}

fn main() {
    println!("{}", get_length(Some("hello".to_string()))); // 5
    println!("{}", get_length(None)); // 0
}

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

fn classify_number(n: i32) -> &'static str {
    // 配合条件判断的 let 链
    if let Some(name) = &["positive", "zero", "negative"].get(if n > 0 { 0 } else if n < 0 { 2 } else { 1 }) {
        name
    } else {
        "unknown"
    }
}

fn main() {
    println!("{}", classify_number(-5)); // negative
    println!("{}", classify_number(0)); // zero
    println!("{}", classify_number(4)); // positive
}

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

fn main() {
    // let...else 是 let 链的一部分
    let Some(value) = Some(42) else {
        panic!("没有值！");
    };
    
    println!("值为: {}", value); // 值为: 42
    
    // 更复杂的匹配
    let (Ok(a), Ok(b)) = (Ok(10), Ok(20)) else {
        return;
    };
    
    println!("a + b = {}", a + b); // a + b = 30
}

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

fn main() {
    let a: i8 = 127;    // 8位有符号，范围: -128 ~ 127
    let b: i16 = 32767; // 16位有符号，范围: -32768 ~ 32767
    let c: i32 = 2147483647; // 32位有符号，范围: -2147483648 ~ 2147483647
    let d: i64 = 9223372036854775807; // 64位有符号
    let e: i128 = 170141183460469231731687303715884105727; // 128位有符号！
    
    println!("i8 最大值: {}", i8::MAX); // i8 最大值: 127
    println!("i16 最大值: {}", i16::MAX); // i16 最大值: 32767
    println!("i32 最大值: {}", i32::MAX); // i32 最大值: 2147483647
    println!("i64 最大值: {}", i64::MAX); // i64 最大值: 9223372036854775807
    println!("i128 最大值: {}", i128::MAX); // i128 最大值: 170141183460469231731687303715884105727
}

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

fn main() {
    let a: u8 = 255;    // 8位无符号，范围: 0 ~ 255
    let b: u16 = 65535; // 16位无符号，范围: 0 ~ 65535
    let c: u32 = 4294967295; // 32位无符号，范围: 0 ~ 4294967295
    let d: u64 = 18446744073709551615; // 64位无符号
    let e: u128 = 340282366920938463463374607431768211455; // 128位无符号
    
    println!("u8 最大值: {}", u8::MAX); // u8 最大值: 255
    println!("u16 最大值: {}", u16::MAX); // u16 最大值: 65535
    println!("u32 最大值: {}", u32::MAX); // u32 最大值: 4294967295
    println!("u64 最大值: {}", u64::MAX); // u64 最大值: 18446744073709551615
    println!("u128 最大值: {}", u128::MAX); // u128 最大值: 340282366920938463463374607431768211455
}

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

fn main() {
    // 如果你的数可能是负数，用有符号！
    let temperature: i32 = -10; // 零下10度
    let altitude: i32 = 8848; // 珠穆朗玛峰高度（米）
    
    // 如果你的数永远是正数，用无符号！
    let age: u8 = 25; // 年龄不会是负数
    let population: u64 = 1400000000; // 人口
    let bytes: usize = 1024; // 字节数
    
    println!("温度: {}°C", temperature); // 温度: -10°C
    println!("年龄: {}岁", age); // 年龄: 25岁
}

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

fn main() {
    println!("isize 大小: {} 位", std::mem::size_of::<isize>() * 8); // 64 位
    println!("usize 大小: {} 位", std::mem::size_of::<usize>() * 8); // 64 位
    
    // 典型用途：数组索引
    let arr = [1, 2, 3, 4, 5];
    let index: usize = 2;
    println!("arr[{}] = {}", index, arr[index]); // arr[2] = 3
    
    // usize 用于表示内存大小
    let memory_size: usize = std::mem::size_of::<String>();
    println!("String 类型占用 {} 字节", memory_size); // String 类型占用 24 字节（64位系统）
}

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

fn main() {
    // 没有类型标注？编译器会根据上下文推导
    let a = 42; // 推导为 i32
    let b = 100u8; // 显式指定 u8
    let c = 200u16; // 显式指定 u16
    let d = 300u32; // 显式指定 u32
    let e = 400u64; // 显式指定 u64
    
    println!("a 是 i32: {}", a); // a 是 i32: 42
    println!("b 是 u8: {}", b); // b 是 u8: 100
    
    // 函数参数的类型推导
    let result = sum(1, 2); // 1 和 2 都是 i32，所以函数参数也是 i32
    println!("1 + 2 = {}", result); // 1 + 2 = 3
}

fn sum(a: i32, b: i32) -> i32 {
    a + b
}

1
2
3
4
5
6
7
8

fn main() {
    // i32 是 Rust 的"万能选手"！
    // 原因1：大多数场景下 32 位整数够用
    let population: i32 = 1400000000; // 中国人口，够用！
    
    // 原因2：i32 在 64 位 CPU 上效率最高（一次操作处理完）
    // 原因3：历史原因，保持和 C 语言的兼容性
}

 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

fn main() {
    // 十进制（默认）
    let decimal = 98_765; // 下划线分隔，更易读！
    println!("十进制: {}", decimal); // 十进制: 98765
    
    // 十六进制：0x 开头
    let hex = 0xFF; // 255
    let hex2 = 0xDEADBEEF; // 3735928559
    println!("十六进制: {:#x}", hex); // 十六进制: 0xff
    println!("十六进制: {:#x}", hex2); // 十六进制: 0xdeadbeef
    
    // 八进制：0o 开头
    let octal = 0o77; // 63
    println!("八进制: {:#o}", octal); // 八进制: 0o77
    
    // 二进制：0b 开头
    let binary = 0b1010; // 10
    println!("二进制: {:#b}", binary); // 二进制: 0b1010
    
    // 字节表示（u8专用）
    let byte = b'A'; // 65
    println!("字节: {}", byte); // 字节: 65
    
    // 字节数组字面量
    let bytes = b"hello"; // [104, 101, 108, 108, 111]
    println!("字节数组: {:?}", bytes); // 字节数组: [104, 101, 108, 108, 111]
}

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

fn main() {
    let num = 255;
    
    println!("十进制: {}", num); // 十进制: 255
    println!("十六进制: {:x}", num); // 十六进制: ff
    println!("八进制: {:o}", num); // 八进制: 377
    println!("二进制: {:b}", num); // 二进制: 11111111
    
    // 带前缀的格式化输出
    println!("0x{:02X}", num); // 0xFF（大写，带前导零）
    println!("0b{:08b}", num); // 0b11111111（8位二进制）
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

fn main() {
    let pi: f32 = 3.14159;
    let e: f32 = 2.71828;
    
    println!("π ≈ {}", pi); // π ≈ 3.14159
    println!("e ≈ {}", e); // e ≈ 2.71828
    
    // f32 的精度
    println!("f32 精度: {} 位尾数", std::mem::size_of::<f32>() * 8); // 32 位
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

fn main() {
    let pi = 3.141592653589793; // 默认 f64！
    let e = 2.718281828459045;
    
    println!("π ≈ {:.15}", pi); // π ≈ 3.141592653589793
    println!("e ≈ {:.15}", e); // e ≈ 2.718281828459045
    
    // 显式标注 f64
    let pi: f64 = 3.14159;
    println!("显式 f64: {:.10}", pi); // 显式 f64: 3.1415900000
}

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

fn main() {
    // NaN（Not a Number）
    let nan = f64::NAN;
    println!("NaN: {}", nan); // NaN
    println!("是 NaN 吗？: {}", nan.is_nan()); // 是 NaN 吗？: true
    
    // 无穷大
    let inf = f64::INFINITY;
    let neg_inf = f64::NEG_INFINITY;
    println!("正无穷: {}", inf); // 正无穷
    println!("负无穷: {}", neg_inf); // 负无穷
    println!("是无穷吗？: {}", inf.is_infinite()); // 是无穷吗？: true
    
    // 负零
    let neg_zero = -0.0;
    println!("负零: {}", neg_zero); // -0
    println!("是 -0 吗？: {}", neg_zero.is_sign_negative()); // 是 -0 吗？: true
    
    // 浮点数运算产生的特殊值
    println!("1.0 / 0.0 = {}", 1.0 / 0.0); // 1.0 / 0.0 = Infinity
    println!("-1.0 / 0.0 = {}", -1.0 / 0.0); // -1.0 / 0.0 = -Infinity
    println!("0.0 / 0.0 = {}", 0.0 / 0.0); // 0.0 / 0.0 = NaN
    println!("sqrt(-1.0) = {}", (-1.0_f64).sqrt()); // sqrt(-1.0) = NaN
}

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

fn main() {
    // 经典的精度问题
    let a = 0.1 + 0.2;
    println!("0.1 + 0.2 = {}", a); // 0.1 + 0.2 = 0.30000000000000004
    println!("a == 0.3: {}", a == 0.3); // a == 0.3: false
    
    // 原因：0.1 在二进制里是无限循环小数！
    // 计算机只能存储有限的位数，所以产生了误差
    
    // 正确比较方式：允许一定的误差
    let epsilon = 1e-10; // 允许的误差
    println!("误差范围内相等？: {}", (a - 0.3).abs() < epsilon); // 误差范围内相等？: true
    
    // 使用标准库的方法
    println!("几乎相等？: {}", (a - 0.3).abs() < f64::EPSILON); // 几乎相等？: true
}

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

fn main() {
    // NaN 的特性：它不等于任何数，包括它自己！
    let nan = f64::NAN;
    println!("NaN == NaN: {}", nan == nan); // NaN == NaN: false
    
    // 判断 NaN 的正确方式
    println!("is_nan(): {}", nan.is_nan()); // is_nan(): true
    
    // NaN 在比较运算中的行为
    println!("NaN < 0: {}", nan < 0.0); // NaN < 0: false
    println!("NaN > 0: {}", nan > 0.0); // NaN > 0: false
    println!("NaN <= 0: {}", nan <= 0.0); // NaN <= 0: false
    println!("NaN >= 0: {}", nan >= 0.0); // NaN >= 0: false
    println!("NaN == 0: {}", nan == 0.0); // NaN == 0: false
    
    // 所以判断一个浮点数是否是 NaN 的唯一方式
    fn is_nan(x: f64) -> bool {
        x != x // 如果 x 是 NaN，这永远为 true！
    }
    
    println!("自定义 is_nan: {}", is_nan(nan)); // 自定义 is_nan: true
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

fn main() {
    let is_rust_awesome = true;
    let is_java_perfect = false;
    
    println!("Rust 很棒: {}", is_rust_awesome); // Rust 很棒: true
    println!("Java 完美: {}", is_java_perfect); // Java 完美: false
    
    // bool 占 1 字节（虽然是 1 bit 就够了）
    println!("bool 大小: {} 字节", std::mem::size_of::<bool>()); // bool 大小: 1 字节
}

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

fn main() {
    let a = true;
    let b = false;
    
    // 与运算：&&（两个都为 true 才为 true）
    println!("true && true = {}", a && a); // true && true = true
    println!("true && false = {}", a && b); // true && false = false
    
    // 或运算：||（至少一个为 true 就为 true）
    println!("true || false = {}", a || b); // true || false = true
    println!("false || false = {}", b || b); // false || false = false
    
    // 非运算：!（取反）
    println!("!true = {}", !a); // !true = false
    println!("!false = {}", !b); // !false = true
    
    // 短路求值：&& 和 || 都会短路
    let result = b && {
        println!("这行永远不会打印！");
        true
    };
    println!("b && ... = {}", result); // b && ... = false
}

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

fn main() {
    // C 语言的写法在 Rust 里行不通！
    // let x = 1;
    // if (x) { ... } // 编译错误！Rust 不会自动转换！
    
    // 正确写法
    let x = 1;
    if x != 0 {
        println!("x 不为零"); // x 不为零
    }
    
    // 或者用 bool
    let condition = x > 0;
    if condition {
        println!("x 是正数");
    }
    
    // 三元运算符在 Rust 里是这样的：
    let y = if x > 0 { 1 } else { -1 };
    println!("y = {}", y); // y = 1
}

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

fn main() {
    let b = true;
    
    // 转换为字符串
    println!("to_string(): {}", b.to_string()); // to_string(): true
    
    // 转换为_owned（克隆）
    let owned: String = b.to_owned();
    println!("to_owned(): {}", owned); // to_owned(): true
    
    // 注意：bool 没有 as_str() 方法！
    // 下面这行会编译错误：
    // let s: &str = b.as_str(); // 错误：bool 没有 as_str 方法
    
    // 如果你需要 &str，用这个方法：
    let s: &str = if b { "true" } else { "false" };
    println!("作为 &str: {}", s); // 作为 &str: true
}

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

fn main() {
    // char 是 4 字节（32 位），可以表示任何 Unicode 字符
    let c1 = 'a';
    let c2 = '中';
    let c3 = '😀'; // emoji 也没问题！
    
    println!("char 大小: {} 字节", std::mem::size_of::<char>()); // char 大小: 4 字节
    println!("c1 = {}", c1); // c1 = a
    println!("c2 = {}", c2); // c2 = 中
    println!("c3 = {}", c3); // c3 = 😀
    
    // char 的范围：U+0000 ~ U+10FFFF（不含代理对）
    println!("char 最小值: U+{:04X}", char::MIN as u32); // char 最小值: U+0000
    println!("char 最大值: U+{:06X}", char::MAX as u32); // char 最大值: U+10FFFF
}