C++ 与 Rust 对比：同一件事的两种写法

// C++：默认可变，const 是「额外承诺」
int x = 10;         // 可变
x = 20;             // 允许
const int y = 30;   // 不可变
// y = 40;         // 编译错误

// Rust：默认不可变，mut 是「额外授权」
let x = 10;         // 不可变
// x = 20;         // 编译错误：cannot assign twice to immutable variable
let mut y = 30;     // 可变
y = 40;             // 允许

// C++：三种流派并存，写哪种取决于纪律
void cpp_memory() {
    int stack_val = 42;                        // 栈：自动释放

    int* raw = new int(42);                    // 裸 new：合法但危险
    delete raw;                                // 忘了这行 = 泄漏；删两次 = 崩溃

    auto unique = std::make_unique<int>(42);   // 独占所有权（推荐）
    auto shared = std::make_shared<int>(42);   // 共享所有权 + 引用计数
}   // 智能指针离开作用域自动释放

// Rust：只有一种答案，且是默认行为
fn rust_memory() {
    let stack_val = 42;               // 栈：作用域结束自动释放

    let owned = Box::new(42);         // 堆分配，独占所有权（对应 unique_ptr）
    let r1 = std::rc::Rc::new(42);    // 共享所有权（对应 shared_ptr，非线程安全）
    let r2 = std::rc::Rc::clone(&r1); // 引用计数 +1

    // 不存在裸 new/delete，也没有「忘了释放」这个错误类别
}

// C++：两条路并存，团队规范决定用哪条
int divide_throw(int a, int b) {
    if (b == 0) throw std::runtime_error("divide by zero");  // 路 A：异常
    return a / b;
}

std::optional<int> divide_opt(int a, int b) {
    if (b == 0) return std::nullopt;                          // 路 B：值编码失败
    return a / b;
}

// Rust：只有一条路，且函数签名即文档
fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        return Err(String::from("divide by zero"));
    }
    Ok(a / b)
}

fn main() -> Result<(), String> {
    let r = divide(10, 2)?;   // ? 运算符：出错就向上传播，成功则解包
    println!("{r}");
    Ok(())
}

// C++：std::string（拥有）+ std::string_view（借用）
std::string name = "zhang";
name += " san";
std::cout << name.size();            // 字节数（UTF-8 中文一个字 3 字节）

std::string_view view = name;        // 不拥有数据，零拷贝
std::string msg = std::format("hi, {}!", name);   // C++20 格式化

// Rust：String（拥有）+ &str（借用切片）
let mut name = String::from("zhang");
name.push_str(" san");
println!("{}", name.len());          // 同样是字节数

let view: &str = &name;              // 不拥有数据，零拷贝
let msg = format!("hi, {name}!");    // 内插格式化

// C++：能保护，但不强制
std::mutex mtx;
int counter = 0;

std::vector<std::thread> threads;
for (int i = 0; i < 10; i++) {
    threads.emplace_back([&]() {
        std::lock_guard<std::mutex> lock(mtx);
        counter++;
    });
}
for (auto& t : threads) t.join();

// 下面的代码同样编译通过——但它是数据竞争，未定义行为：
// int unsafe_counter = 0;
// std::thread t1([&]{ unsafe_counter++; });
// std::thread t2([&]{ unsafe_counter++; });

// Rust：编译器替你锁门
use std::sync::{Arc, Mutex};
use std::thread;

let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
    let counter = Arc::clone(&counter);
    handles.push(thread::spawn(move || {
        let mut num = counter.lock().unwrap();
        *num += 1;
    }));
}
for h in handles { h.join().unwrap(); }

// 下面的代码编译不过：
// let mut unsafe_counter = 0;
// thread::spawn(|| { unsafe_counter += 1; });
// 错误：closure may outlive... `i32` cannot be shared between threads safely

// C++20：concepts 约束模板参数
#include <concepts>

template <typename T>
requires std::integral<T>
T sum(const std::vector<T>& v) {
    T total = 0;
    for (const auto& x : v) total += x;
    return total;
}

// Rust：trait 约束泛型
fn sum<T: std::ops::Add<Output = T> + Default + Copy>(values: &[T]) -> T {
    let mut total = T::default();
    for v in values { total = total + *v; }
    total
}

// C++17：std::variant + std::visit 模拟「带数据的枚举」
using Value = std::variant<int, double, std::string>;

void process(const Value& v) {
    std::visit([](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, int>)        std::cout << "int: " << arg;
        else if constexpr (std::is_same_v<T, double>) std::cout << "double: " << arg;
        else                                          std::cout << "string: " << arg;
    }, v);
}

// Rust：枚举天生携带数据，match 强制穷举
enum Value {
    Integer(i32),
    Float(f64),
    Text(String),
}

fn process(v: &Value) {
    match v {
        Value::Integer(n) => println!("int: {n}"),
        Value::Float(f)   => println!("double: {f}"),
        Value::Text(s)    => println!("string: {s}"),
        // 漏写任何一个变体，编译错误
    }
}

// Rust 侧：src/lib.rs
#[no_mangle]                      // 不做名字修饰，保持 C 可见
pub extern "C" fn rust_add(a: i32, b: i32) -> i32 {
    a + b
}

# Cargo.toml：产出静态库
[lib]
crate-type = ["cdylib", "staticlib"]

// C++ 侧：声明并链接
extern "C" {
    int rust_add(int a, int b);
}

int main() {
    std::cout << rust_add(3, 5);   // 8
}

// build.rs：编译 C++ 源并生成绑定
fn main() {
    let bindings = bindgen::Builder::default()
        .header("src/cpp_api.h")
        .clang_arg("-xc++")
        .generate()
        .expect("generate bindings");

    bindings
        .write_to_file(std::path::PathBuf::from("src/bindings.rs"))
        .expect("write bindings");
}