Rust vs C++：安全换性能？

你听说过 Rust 比 C++ 安全，但 C++ 性能更强。

真是这样吗？Rust 的安全体现在哪？会牺牲性能吗？

这篇文章结合 2025 年最新对比分析，一次讲透。

先说结论

Rust 的安全 = 编译期强制管内存，不允许写出崩的代码
C++ 的自由 = 随便玩，崩了算你的
性能上：两者几乎一样，Rust 有时甚至更快

C++ 的内存问题

C++ 给你完全的内存控制权，但这也意味着：

你可以做的事（很危险）

// 1. 内存释放了还继续用（悬空指针/Use-after-free）
int* ptr = new int(10);
delete ptr;
cout << *ptr;  // 💥 未定义行为：可能崩溃、可能输出垃圾值

// 2. 数组越界乱访问（Buffer Overflow）
int arr[5];
arr[10] = 100;  // 💥 未定义行为：可能崩、可能数据错

// 3. 同一个内存多人改（数据竞争）
int* data = new int(0);
thread t1([&] { *data += 1; });
thread t2([&] { *data += 1; });  // 💥 数据竞争：结果不确定

// 4. 空指针乱指
int* ptr = nullptr;
*ptr = 10;  // 💥 直接崩溃

后果是什么？

场景后果
个人小软件闪退，重启就行
服务器程序整个服务挂掉，影响所有用户
长期运行程序内存越漏越多，最后卡死
安全敏感黑客利用内存漏洞偷数据、控制机器

根据美国国家漏洞数据库（NVD）统计，约 70% 的安全漏洞源于内存安全问题。

现代 C++ 也在进步

值得注意的是：现代 C++（C++11 及以后）提供了强大的工具来避免这些问题。

C++11/14/17/20 的安全工具

工具说明对应 Rust 概念
std::unique_ptr独占所有权，自动释放Box<T>
std::shared_ptr共享所有权，引用计数Arc<T> / Rc<T>
std::weak_ptr弱引用，避免循环引用弱引用
std::vector::at()边界检查，越界抛异常Rust 默认边界检查
RAII资源获取即初始化Rust 所有权模型

C++ 智能指针示例

// 现代 C++ 推荐写法
#include <memory>

void modern_cpp() {
    // unique_ptr：独占所有权，自动释放
    auto ptr = std::make_unique<int>(42);
    // 离开作用域自动 delete，不会泄漏

    // shared_ptr：共享所有权
    auto shared = std::make_shared<int>(100);
    // 引用计数归零时自动释放
}

但关键区别：C++ 这些是可选的，需要程序员主动使用。Rust 是强制的，编译器不允许你写出不安全的代码。

Rust 怎么解决？

Rust 在 编译阶段 就把所有内存错误全部拦住。

核心机制：所有权 + 借用检查

// Rust 不让你写崩的代码，编译时就报错

// 1. 悬空指针？编译器阻止
let r;
{
    let x = 5;
    r = &x;  // ❌ 编译错误：`x` 的生命周期不够长
} // `x` 被释放
println!("{}", r);  // 编译失败：不能用失效的引用

// 2. 数组越界？编译期检测或运行时 panic
let arr = [1, 2, 3, 4, 5];
let val = arr[10];  // ❌ 编译时常量越界直接报错
// 动态越界运行时 panic，不会是未定义行为

// 3. 数据竞争？编译器直接禁止
let mut data = vec![1, 2, 3];
let r1 = &data[0];      // 不可变借用
let r2 = &mut data[0];  // ❌ 编译错误：不可变和可变不能共存

// 4. 空指针？Rust 根本没有 null 引用
// Rust 用 Option<T> 表示可能为空的值
fn get_value(maybe: Option<&i32>) -> i32 {
    match maybe {
        Some(v) => *v,  // 安全解引用
        None => 0,       // 处理空情况
    }
}

Rust 严格管三件事

机制作用C++ 对应
所有权谁拥有这块内存RAII + unique_ptr
借用谁能读（&T） vs 谁能写（&mut T）指针 + 纪律
生命周期引用有效多久悬空指针问题
C++：信任程序员，你可以做危险的事
Rust：编译器不信任你，证明你的代码安全才让编译

性能对比：两者几乎一样

2025 年基准测试数据

测试项目C++Rust差距
斐波那契计算~22 ms~22 ms持平
JSON 解析基准 1.00.9 ~ 1.1±10%
数值计算基准 1.00.95 ~ 1.05±5%
内存占用基准0.8 ~ 1.2取决于代码风格

结论：两者几乎一样快，某些场景 Rust 更快（没有虚函数表开销、更好的优化）。

为什么 Rust 不会更慢？

Rust 的安全检查 → 全在编译期完成
编译完成后 → 和 C++ 一样，直接跑机器码
运行时 → 零成本抽象（Zero-cost abstractions）

Rust 的设计哲学是：不为你没用到的功能付费。

对比表（2025 版）

维度C++Rust
内存安全❌ 靠程序员自觉 + 可选工具✅ 编译器强制
编译速度🚀 快🐌 慢（借用检查耗时）
运行速度⚡ 极快⚡ 极快（几乎一样）
学习曲线😐 中等😰 困难（需转变思维）
开发速度😐 中等🚀 快（写完就稳，少调试）
调试时间💸 大量运行时错误💚 编译期发现大部分
生态🏆 巨大（40年积累）📈 快速增长
编译期检查⚠️ 可选警告✅ 强制要求
并发安全❌ 数据竞争未定义行为✅ 编译期防止数据竞争

真实场景对比

场景 1：个人小工具

C++：随便写，崩了重启，无所谓
Rust：编译期阻止你犯错，更稳
→ 两者都行，看个人偏好

场景 2：大型服务器

C++：一个内存漏洞可能被黑客利用
Rust：编译期就堵死这类漏洞
→ Rust 更安全，企业级应用首选

场景 3：嵌入式/车机/医疗

C++：崩溃后果严重，需要大量测试
Rust：编译期保证内存安全
→ Rust 明显更好（安全关键系统）

场景 4：游戏引擎

C++：生态成熟，大量现成代码和库
Rust：新项目可以考虑，老项目迁移成本高
→ C++ 依然主流，但 Rust 在增长

为什么 C++ 依然主流？

如果 Rust 又安全又快，为什么 C++ 还在用？

1. 历史包袱 + 生态

C++：40 年历史，所有领域都有现成代码
      操作系统、浏览器、游戏引擎、数据库...
Rust：2010 年才诞生（15年），生态还在追赶
      但增长迅速，Linux 内核已部分采用 Rust

2. 人才储备

C++：满大街都是 C++ 程序员
Rust：人才相对稀缺，薪资更高

3. 迁移成本

一个大型 C++ 项目 → 重写成 Rust？
成本巨大，风险高，通常不太现实

更现实的做法：新模块用 Rust，旧代码保持 C++

4. 学习曲线

C++：难学，但很多概念直观（指针就是地址）
Rust：难学，所有权/生命周期需要思维转变
      很多 C++ 程序员第一次遇到借用检查器会崩溃

终极总结

这三句就够了

Rust 安全 = 编译期强制管内存，不允许写出崩溃代码
C++ 自由 = 随便玩，崩了算你的
性能上：两者几乎一样，没有虚拟机、没有垃圾回收

选型建议

场景推荐
新项目、重视安全Rust
大型遗留系统C++（逐步引入 Rust）
游戏引擎/实时渲染C++（生态成熟）
嵌入式/车机/安全关键Rust（编译期保证）
学习系统编程先 C++ 后 Rust，或直接 Rust
命令行工具Rust（Cargo 体验极佳）

超简比喻

C++  = 给你一把锋利的刀
        切菜也行，伤手也行

Rust  = 给你一把带安全保护装置的刀
        用不了伤手的方式，但需要学习如何使用

行业趋势

2025 年的重要变化：Microsoft、Amazon、Google 都在用 Rust 重写关键组件。

  • Windows 内核：开始支持 Rust 驱动
  • Android：Rust 成为系统语言
  • Linux 内核：接受非 Rust 代码
  • Firefox：大量使用 Rust

趋势是明确的： 新项目优先 Rust，老项目 C++ + Rust 混合。

comments: true

参考资料