为什么说Rust让C++程序员夜不能寐？我踩过的那些坑告诉你答案

// 这种代码我写过太多次了
char* process_data(const char* input) {
    char* result = new char[1024];
    // 做一些处理...
    return result; // 调用方记得delete吗？
}

fn process_data(input: &str) -> String {
    let mut result = String::new();
    // 处理逻辑...
    result // 自动管理，安全返回
}

// 这样写很舒服，性能也不差
let sum: i32 = data.iter()
    .filter(|&x| *x > 0)
    .map(|x| x * x)
    .sum();

// C++里的痛苦经历
std::mutex data_mutex;
std::vector<int> shared_data;

void worker_thread() {
    std::lock_guard<std::mutex> lock(data_mutex);
    // 忘记解锁？死锁等着你
    // 锁的粒度太大？性能完蛋
}

use std::sync::Arc;
use std::thread;

let data = Arc::new(vec![1, 2, 3]);
let data_clone = Arc::clone(&data);

thread::spawn(move || {
    // 这里只能读，不能写，编译器保证安全
    println!("{:?}", data_clone);
});

# 这种配置见过太多次
find_package(Boost REQUIRED COMPONENTS system filesystem)
find_package(OpenSSL REQUIRED)
target_link_libraries(myapp ${Boost_LIBRARIES} ${OPENSSL_LIBRARIES})
# 然后在不同机器上各种编译失败...

cargo new my_project
cd my_project
cargo add serde  # 添加依赖
cargo run        # 编译运行

// C++的痛苦
if (status == CONNECTING) {
    if (retry_count < 3) {
        // 处理重试逻辑
    } else {
        // 处理失败
    }
} else if (status == CONNECTED && has_data) {
    // 处理数据
}
// 越写越复杂...

match (status, retry_count, has_data) {
    (Status::Connecting, count, _) if count < 3 => retry(),
    (Status::Connecting, _, _) => fail(),
    (Status::Connected, _, true) => process_data(),
    (Status::Connected, _, false) => wait(),
    _ => unreachable!(),
}

// 这种代码风险很大
User* findUser(int id) {
    // 可能返回nullptr
    return user_map.find(id) != user_map.end() ? &user_map[id] : nullptr;
}

void processUser(int id) {
    User* user = findUser(id);
    // 忘记检查nullptr？程序崩溃
    user->doSomething();
}

fn find_user(id: u32) -> Option<&User> {
    users.get(&id)
}

fn process_user(id: u32) {
    match find_user(id) {
        Some(user) => user.do_something(),
        None => println!("User not found"),
    }
    // 编译器强制你处理None的情况
}

// C++的繁琐
#include <gtest/gtest.h>

TEST(MathTest, Addition) {
    EXPECT_EQ(2 + 2, 4);
}

// 还要各种配置文件...

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

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 2), 4);
    }
}

// C++里的难题
int global_counter = 0;

void some_function() {
    // 在某个深层嵌套的代码里
    global_counter = 999; // 谁改的？为什么改？
}

let counter = 0;              // 不可变
let mut mutable_counter = 0;  // 可变，一眼就能看出来

// counter = 1;           // 编译错误
mutable_counter = 1;      // OK

// 这种代码很危险
int result = risky_operation();
// 忘记检查返回值，直接使用
process_result(result); // 可能传入了-1

fn read_config() -> Result<Config, ConfigError> {
    let content = std::fs::read_to_string("config.toml")?;
    parse_config(&content)
}

// 使用时必须处理错误
match read_config() {
    Ok(config) => println!("Config loaded: {:?}", config),
    Err(e) => eprintln!("Failed to load config: {}", e),
}

# Cargo.toml里简单几行
[dependencies]
tokio = "1.0"
serde = { version = "1.0", features = ["derive"] }
actix-web = "4.0"