一、Trait系统与多态（从虚函数到零成本抽象）

接口定义对比

C++虚函数与纯虚类：

// 接口定义
class Drawable {
public:
    virtual void draw() const = 0;
    virtual ~Drawable() = default;
};

// 具体实现
class Circle : public Drawable {
    void draw() const override { /*...*/ }
};

Rust的trait实现：

// Trait定义
trait Drawable {
    fn draw(&self);
}

// 结构体实现
struct Circle;
impl Drawable for Circle {
    fn draw(&self) { /*...*/ }
}

关键差异表：

泛型约束对比

C++20概念与Rust trait约束：

// C++20概念
template
concept Drawable = requires(const T& t) {
    { t.draw() } -> std::same_as;
};

template
void render(const T& obj) { obj.draw(); }

// Rust trait约束
fn render(obj: &T) {
    obj.draw();
}

// 或使用where从句
fn render(obj: &T)
where
    T: Drawable + Clone
{ /*...*/ }

二、智能指针深度解析（从C++指针到Rust安全包装）

常见智能指针对比

内部可变性模式

C++的mutable陷阱：

class Cache {
    mutable std::mutex mtx;  // 逻辑const但物理可变
    mutable int access_count = 0;

public:
    int get(int key) const {
        std::lock_guard lock(mtx);  // const方法修改mutex
        ++access_count;             // 修改成员变量
        // ...
    }
};

Rust的安全实现：

struct Cache {
    data: RwLock>,
    access_count: AtomicUsize,  // 原子操作
}

impl Cache {
    fn get(&self, key: i32) -> Option {
        let _guard = self.data.read().unwrap();
        self.access_count.fetch_add(1, Ordering::Relaxed);
        // ...
    }
}

三、并发编程模型（从线程安全到无畏并发）

线程创建对比

C++标准线程：

std::vector threads;
for (int i=0; i<5; ++i) {
    threads.emplace_back([i] {
        std::cout << "Thread " << i << std::endl;
    });
}
for (auto& t : threads) t.join();

Rust的移动语义保证：

let handles: Vec<_> = (0..5).map(|i| {
    thread::spawn(move || {  // 显式转移所有权
        println!("Thread {}", i);
    })
}).collect();

for handle in handles {
    handle.join().unwrap();
}

同步原语对比

安全访问示例：

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;
    }));
}

四、Unsafe与FFI（与C/C++的互操作）

不安全代码对比

C++默认不安全：

// 合法的危险代码
int* ptr = (int*)0x1234;
*ptr = 42;  // 未定义行为

Rust的安全边界：

unsafe {
    let ptr = 0x1234 as *mut i32;
    *ptr = 42;  // 必须在unsafe块中
}

C++互操作示例

Rust调用C++函数：

// 声明外部函数
#[link(name = "cpplib")]
extern "C" {
    fn cpp_add(a: i32, b: i32) -> i32;
}

// 安全包装
pub fn safe_add(a: i32, b: i32) -> Result {
    unsafe { Ok(cpp_add(a, b)) }
}

C++调用Rust函数：

// Rust侧
#[no_mangle]
pub extern "C" fn rust_multiply(a: i32, b: i32) -> i32 {
    a * b
}

// C++侧
extern "C" {
    int rust_multiply(int a, int b);
}

int main() {
    std::cout << rust_multiply(3, 4);  // 输出12
}

五、元编程与高级特性

宏系统对比

C++模板元编程：

template
constexpr auto type_name() {
    return std::string_view(__PRETTY_FUNCTION__)
        .substr(32, sizeof(__PRETTY_FUNCTION__)-34);
}

Rust声明宏：

macro_rules! vec {
    ($($x:expr),*) => {
        {
            let mut temp_vec = Vec::new();
            $(temp_vec.push($x);)*
            temp_vec
        }
    };
}

let v = vec![1, 2, 3];  // 使用宏

泛型实现机制

C++模板实例化：

template
struct Wrapper { T value; };

// 编译生成具体类型
Wrapper w1;
Wrapper w2;

Rust的Monomorphization：

struct Wrapper { value: T }

// 编译时生成具体实现
let w1: Wrapper = ...;
let w2: Wrapper = ...;

六、工程实践与生态工具

项目管理对比

现代特性支持

// 异步编程（对比C++协程）
async fn fetch_data(url: &str) -> Result {
    reqwest::get(url).await?.text().await
}

// 模式匹配增强
match value {
    1..=5 => println!("1-5"),
    Some(x) if x > 10 => println!(">10"),
    _ => println!("other"),
}

七、从C++到Rust的思维转变

哲学差异总结

学习路径建议

1. 从所有权系统入手，理解移动语义
2. 掌握Result/Option的错误处理范式
3. 深入trait系统实现多态
4. 学习借用检查器的"思维语言"
5. 用cargo管理项目，拥抱现代工具链
6. 在unsafe代码中寻找安全边界

// Rust的终极哲学体现在这里
fn main() {
    let mut journey = LearningJourney::new();
    loop {
        match journey.step() {
            Ok(knowledge) => knowledge.apply(),
            Err(e) => eprintln!("Error: {}", e),
        }
    }
}

通过本系列三篇指南，C++程序员可以建立起从C++到Rust的认知桥梁。Rust不是要取代C++，而是在系统编程领域提供了一个更安全的现代化选择。掌握这两种语言将使您成为更全面的系统级开发者，既能处理遗留代码，又能编写安全高效的新时代软件。