void process(std::vector<int>& data) {
    // data 是引用，调用者仍持有所有权
    // 可能被传入悬空引用！
}

int main() {
    std::vector<int>* ptr = new std::vector<int>{1,2,3};
    process(*ptr);
    delete ptr;  // data 的引用可能已失效
    // 更好的做法：使用智能指针
}

fn process(data: &Vec<i32>) {
    // data 是借用，不获取所有权
    // 编译器保证引用有效性
}

fn main() {
    let v = vec![1, 2, 3];
    process(&v);  // 借用检查器验证生命周期
    // v 仍有效，可继续使用
}

// 悬空引用？编译错误！
fn dangle() -> &String {
    let s = String::from("hello");
    &s  // 编译错误：s 在函数结束时销毁
}

struct Person {
    std::string name;
    std::string* address;  // 指向 name 的指针？
};

Person& find_older(Person& a, Person& b) {
    // 返回的引用指向谁？调用者必须查看实现
    // 如果 a 或 b 被销毁，返回引用悬空！
    return (a.age > b.age) ? a : b;
}

struct Person<'a> {
    name: &'a str,  // 生命周期绑定到 Person
}

fn older<'a>(a: &'a Person<'a>, b: &'a Person<'a>) 
    -> &'a Person<'a> 
{
    // 返回值的生命周期 = 输入中较短的那个
    // 编译器静态保证返回值有效
}

task<int> async_fetch(int id) {
    co_await fetch_from_network(id);  // 挂起/恢复
    co_return 42;
}

// 使用
auto result = async_fetch(1).get();

协程状态机由编译器生成，但语义取决于运行时库（MSVC/ libstdc++/ libc++）。

async fn fetch(id: i32) -> i32 {
    some_async_operation(id).await;  // 状态机转换
    42
}

// 使用
let result = fetch(1).await;

// async trait（Rust 1.75+）
trait Service {
    async fn call(&self, req: Request) -> Response;
}

Executor 生态独立于标准库（Tokio/async-std），但语义一致性好。

template<typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
};

template<Addable T>
T max(T a, T b) {
    return a > b ? a : b;
}

trait Addable {
    fn add(self, other: Self) -> Self;
}

fn max<T: Addable>(a: T, b: T) -> T {
    if a > b { a } else { b }
}

auto result = view::iota(1, 100)
    | view::filter([](int n){ 
        return n % 2 == 0; 
    })
    | view::transform([](int n){ 
        return n * 2; 
    })
    | to_vector;

let result: Vec<i32> = (1..100)
    .filter(|&n| n % 2 == 0)
    .map(|n| n * 2)
    .collect();

• 标准库：功能全面但相对基础
• 第三方库：Boost（全能型）、Abseil（Google）、folly（Facebook）
• 构建系统：CMake 占主导，Meson、Bazel 正在崛起
• 包管理：vcpkg（微软）、Conan（社区）
• 学习曲线：陡峭但有大量历史资源

• 标准库：更高级的抽象（async、futures、智能指针）
• crates.io：超过 140,000 crate，品质普遍较高
• 构建系统：Cargo 内置，包管理和测试一体化
• 工具链：rustup、rustfmt、rust-analyzer、clippy
• 学习曲线：前期陡峭（所有权），后期平缓

// Rust 导出
#[no_mangle]
pub extern "C" fn rust_process(
    data: *const u8, 
    len: usize
) -> i32 {
    let slice = unsafe {
        std::slice::from_raw_parts(data, len)
    };
    // 处理逻辑
    process_inner(slice)
}

// C++ 调用
extern "C" {
    int rust_process(const uint8_t* data, size_t len);
}

// 声明外部 C 函数
extern "C" {
    fn c_compute(x: c_int, y: c_int) -> c_int;
}

fn rust_wrapper(x: i32, y: i32) -> i32 {
    unsafe { c_compute(x, y) }
}