返回专栏
· 22 分钟阅读

Rust 与 C++ 的区别


一、Rust 与 C++ 是什么?

Rust 和 C++ 都属于系统级编程语言,广泛应用于操作系统、数据库、游戏引擎、网络服务、浏览器和高性能计算等领域。

两者都能够生成原生机器码,支持低级内存操作、泛型、抽象和并发编程,但在内存管理、类型系统和语言设计理念方面存在明显差异。

1. Rust 是什么?

Rust 是一门由 Mozilla Research 最初推动、现由 Rust 基金会及开源社区共同维护的系统编程语言。

Rust 的核心设计目标是在保持接近 C/C++ 性能和底层控制能力的同时,通过编译期检查减少内存安全问题和数据竞争。

主要特点:

  • 所有权机制:通过所有权规则管理值的生命周期。
  • 借用与引用:允许在不转移所有权的情况下访问数据。
  • 生命周期检查:确保引用不会超过其所引用数据的有效生命周期。
  • 内存安全:在安全 Rust 中避免大量悬垂引用、重复释放等问题。
  • 零成本抽象:泛型、迭代器等抽象通常可以在编译期优化。
  • 并发安全:通过 Send、Sync 等 trait 和所有权规则,在编译期约束跨线程数据访问。

Rust 示例:

fn main() {
    let message = String::from("Hello, Rust!");
    println!("{}", message);
}

Rust 不需要开发者手动释放这个 String。当其所有权离开作用域时,相关资源会按照析构规则自动释放。

2. C++ 是什么?

C++ 是由 Bjarne Stroustrup 在 C 语言基础上发展起来的通用编程语言,最初被称为带类的 C,后来逐渐发展为支持多范式的大型语言体系。

C++ 兼具底层控制能力和高级抽象能力,支持面向过程、面向对象、泛型和函数式编程等风格。

主要特点:

  • 高性能:通常编译为原生机器码。
  • 底层控制:支持指针、内存布局和资源管理控制。
  • 面向对象:支持类、继承、虚函数和多态。
  • 泛型编程:通过模板实现编译期泛型。
  • RAII:利用对象生命周期自动管理资源。
  • 生态成熟:在游戏引擎、操作系统、数据库和基础设施领域应用广泛。

C++ 示例:

#include <iostream>
#include <string>

int main() {
    std::string message = "Hello, C++!";
    std::cout << message << std::endl;

    return 0;
}

C++ 同样可以通过对象生命周期和 RAII 自动释放资源,不意味着现代 C++ 必须手动调用 free() 或 delete。

二、Rust 与 C++ 的核心区别

两种语言的主要差异不是能否访问底层内存,而是如何管理内存、约束引用关系和表达并发安全。

对比维度 Rust C++
语言定位 内存安全导向的系统编程语言 通用高性能系统编程语言
编译结果 原生机器码 原生机器码
内存管理 所有权、借用、生命周期 RAII、智能指针、手动管理等
垃圾回收 默认不使用 GC 默认不使用 GC
悬垂引用 安全 Rust 中通过编译检查防止 可能发生,需要开发者保证
数据竞争 安全 Rust 中通过类型系统约束 需要同步机制和正确使用内存模型
指针 引用、原始指针、智能指针 原始指针、引用、智能指针
泛型 泛型与 trait 模板与概念
多态 trait、枚举、泛型 继承、虚函数、模板等
异常处理 Result、Option、panic! 异常、错误码、结果类型等
并发 Send、Sync、线程与异步机制 线程库、原子操作、锁与协程库
编译器 rustc、LLVM 等 GCC、Clang、MSVC 等
包管理 Cargo CMake、Conan、vcpkg 等工具
典型应用 系统组件、基础设施、安全关键模块 游戏引擎、数据库、操作系统、嵌入式

需要注意,Rust 的内存安全保证主要适用于安全 Rust。使用 unsafe、外部函数接口或存在缺陷的底层抽象时,仍然可能引入内存安全问题。

三、内存管理机制的区别

内存管理是 Rust 与 C++ 最核心的区别之一。

C++ 通过 RAII、智能指针和对象生命周期管理资源;Rust 则将所有权和借用规则纳入语言类型系统,在编译阶段检查资源访问是否合法。

1. C++:RAII 与资源管理

RAII(Resource Acquisition Is Initialization,资源获取即初始化)是现代 C++ 非常重要的设计思想。

核心思想是:

  • 在对象初始化时获取资源。
  • 在对象销毁时释放资源。
  • 利用对象生命周期保证资源管理。

示例:

#include <iostream>
#include <memory>

class User {
public:
    User() {
        std::cout << "User created\n";
    }

    ~User() {
        std::cout << "User destroyed\n";
    }
};

int main() {
    {
        std::unique_ptr<User> user =
            std::make_unique<User>();
    }

    std::cout << "Scope ended\n";
}

unique_ptr 独占管理对象,当其离开作用域时,会自动释放所管理的对象。

现代 C++ 常见资源管理方式:

方式 作用
自动存储期对象 离开作用域时自动销毁
std::unique_ptr 独占所有权
std::shared_ptr 引用计数共享所有权
std::weak_ptr 弱引用,避免共享指针循环引用
RAII 统一管理资源获取与释放

C++ 仍然允许直接使用原始指针和手动内存管理,因此资源安全很大程度上依赖开发者遵循规范。

2. Rust:所有权机制

Rust 引入了 Ownership(所有权)机制。

每个值在任意时刻都有一个所有者。当所有者离开作用域时,值会被自动销毁。

fn main() {
    let message = String::from("Hello");

    println!("{}", message);
}

message 拥有字符串数据的所有权。

当 message 离开作用域时,Rust 会自动调用相应的析构逻辑释放资源。

Rust 所有权的基本规则:

  1. 每个值都有一个所有者。
  2. 一个值在同一时刻只有一个所有者。
  3. 所有者离开作用域时,值会被销毁。
  4. 所有权可以通过移动转移给其他变量。

3. Rust:移动语义

Rust 在赋值和传参过程中会涉及所有权移动。

fn main() {
    let first = String::from("Hello");

    let second = first;

    println!("{}", second);

    // 编译错误:first 的所有权已经移动
    // println!("{}", first);
}

执行:

let second = first;

之后,second 成为字符串的所有者,first 不再拥有该值。

这种机制能够在编译阶段避免多个变量同时拥有同一资源并重复释放的问题。

C++ 也支持移动语义:

#include <iostream>
#include <string>
#include <utility>

int main() {
    std::string first = "Hello";

    std::string second = std::move(first);

    std::cout << second << std::endl;
}

不过,C++ 的 std::move 本身只是将表达式转换为右值引用形式,真正的资源转移由移动构造函数或移动赋值运算符决定。移动后的对象仍然有效,但其具体状态由类型的操作契约决定。

Rust 则将移动规则直接纳入语言的所有权检查体系。

4. Rust:借用与引用

Rust 可以通过引用访问数据,而不转移所有权。

不可变借用:

fn print_message(message: &String) {
    println!("{}", message);
}

fn main() {
    let message = String::from("Hello");

    print_message(&message);

    println!("{}", message);
}

可变借用:

fn append_message(message: &mut String) {
    message.push_str(" Rust");
}

fn main() {
    let mut message = String::from("Hello");

    append_message(&mut message);

    println!("{}", message);
}

Rust 的借用规则:

  • 可以存在多个不可变引用。
  • 同一时刻不能同时存在可变引用和其他引用。
  • 引用必须在其所引用数据有效的范围内使用。

这些规则帮助编译器检查潜在的数据竞争和悬垂引用问题。

5. 内存管理机制对比

对比维度 Rust C++
资源释放 所有权与析构机制 RAII 与析构机制
默认所有权 单一所有者 由对象和资源管理策略决定
共享所有权 Rc、Arc shared_ptr
独占所有权 默认所有权、Box 等 unique_ptr
借用 引用与借用检查 引用、指针和约定
生命周期检查 编译器静态检查 主要依赖类型设计和开发者保证
手动释放 安全 Rust 通常不需要 可以使用 delete、free 等
循环引用 Rc 可能形成循环,使用 Weak 处理 shared_ptr 可能形成循环,使用 weak_ptr 处理

需要特别强调:Rust 生命周期注解不会延长对象本身的生命周期,而是帮助编译器验证引用关系是否合法。

四、生命周期机制的区别

Rust 与 C++ 都存在对象生命周期,但两种语言对生命周期的处理方式不同。

C++ 主要通过存储期、作用域和对象生命周期规则管理对象;Rust 则在此基础上增加了引用生命周期的静态检查。

1. C++:对象生命周期

C++ 对象可能具有不同存储期:

  • 自动存储期:通常对应函数或代码块中的局部对象。
  • 静态存储期:程序运行期间持续存在。
  • 线程存储期:每个线程拥有独立实例。
  • 动态存储期:通过动态分配创建,直到显式释放或由资源管理对象释放。

示例:

#include <memory>

int globalValue = 100;

void example() {
    int localValue = 200;

    auto user = std::make_unique<int>(300);
}

这里:

  • globalValue 具有静态存储期。
  • localValue 具有自动存储期。
  • user 本身是自动存储期对象,所管理的整数通过动态分配创建。

2. Rust:生命周期检查

Rust 使用生命周期检查保证引用不会超过数据的有效范围。

fn main() {
    let message = String::from("Hello");

    let reference = &message;

    println!("{}", reference);
}

reference 借用了 message,其有效使用范围必须符合 message 的生命周期。

3. 生命周期标注

当函数返回引用时,Rust 可能需要显式生命周期参数来描述引用之间的关系。

fn longest<'a>(
    first: &'a str,
    second: &'a str
) -> &'a str {
    if first.len() > second.len() {
        first
    } else {
        second
    }
}

'a 表示返回引用与输入引用之间的生命周期约束。

它并不是一个运行时变量,也不会延长字符串数据的实际存活时间。

4. 悬垂引用

C++ 允许开发者写出悬垂引用:

int& getValue() {
    int value = 100;
    return value;
}

函数返回后,局部变量 value 的生命周期已经结束,返回引用不再有效。

这是未定义行为。

Rust 会在编译阶段拒绝类似代码:

fn get_value() -> &i32 {
    let value = 100;
    &value
}

因为返回引用指向的局部变量会在函数结束时销毁。

5. 生命周期机制对比

对比维度 Rust C++
对象生命周期 由作用域、所有权等决定 由存储期和对象生命周期规则决定
引用有效性 编译器进行生命周期检查 主要由程序设计保证
生命周期标注 支持显式生命周期参数 没有 Rust 式生命周期参数
悬垂引用 安全 Rust 中通常在编译期阻止 可能产生未定义行为
资源释放 所有权与析构机制 RAII 与析构机制

五、指针与引用的区别

Rust 和 C++ 都支持直接访问内存,但对指针和引用的约束不同。

1. C++ 指针

C++ 提供原始指针,可以直接保存对象地址。

#include <iostream>

int main() {
    int value = 100;

    int* pointer = &value;

    std::cout << *pointer << std::endl;
}

C++ 原始指针具有较高灵活性,但也容易产生:

  • 空指针解引用。
  • 悬垂指针。
  • 野指针。
  • 重复释放。
  • 越界访问。

现代 C++ 通常建议优先使用智能指针和容器,减少不必要的原始指针操作。

2. Rust 引用

Rust 的普通引用受到借用规则约束。

fn main() {
    let value = 100;

    let reference = &value;

    println!("{}", reference);
}

Rust 的普通引用在安全代码中受到有效性和别名规则约束。

3. Rust 原始指针

Rust 也支持原始指针:

  • *const T:常量原始指针。
  • *mut T:可变原始指针。

示例:

fn main() {
    let value = 100;

    let pointer = &value as *const i32;

    unsafe {
        println!("{}", *pointer);
    }
}

解引用原始指针通常需要进入 unsafe 代码块,因为编译器无法像检查普通引用那样保证原始指针始终有效。

4. 指针机制对比

对比维度 Rust C++
普通引用 &T、&mut T T&、const T&
原始指针 *const T、*mut T T*、const T*
空值处理 普通引用不能为 null,原始指针可以为空 指针可以为 nullptr
可变性 通过引用类型明确区分 通过 const 等规则控制
安全检查 普通引用受借用检查 依赖语言规则和程序设计
原始指针解引用 通常需要 unsafe 可以直接解引用,但必须保证有效性

六、类型系统与抽象能力的区别

Rust 和 C++ 都具有强大的静态类型系统,但抽象机制并不相同。

1. Rust:trait

Rust 使用 trait 定义类型需要满足的行为契约。

trait Animal {
    fn speak(&self);
}

struct Dog;

impl Animal for Dog {
    fn speak(&self) {
        println!("Woof!");
    }
}

fn main() {
    let dog = Dog;
    dog.speak();
}

Dog 通过 impl Animal for Dog 显式实现 Animal。

Rust 可以通过 trait 实现:

  • 泛型约束。
  • 静态分派。
  • 动态分派。
  • 运算符重载。
  • 通用行为抽象。

2. C++:类与虚函数

C++ 可以通过抽象类和虚函数实现运行时多态。

#include <iostream>

class Animal {
public:
    virtual void speak() const = 0;

    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void speak() const override {
        std::cout << "Woof!" << std::endl;
    }
};

int main() {
    Dog dog;
    Animal& animal = dog;

    animal.speak();
}

这里 Animal 是抽象类,Dog 通过继承实现接口行为。

3. 静态分派与动态分派

Rust 泛型通常通过静态分派实现:

trait Animal {
    fn speak(&self);
}

struct Dog;

impl Animal for Dog {
    fn speak(&self) {
        println!("Woof!");
    }
}

fn make_sound<T: Animal>(animal: &T) {
    animal.speak();
}

编译器可以针对具体类型生成相应代码。

Rust 也支持 trait object 实现动态分派:

fn make_sound(animal: &dyn Animal) {
    animal.speak();
}

C++ 模板通常通过编译期实例化实现静态分派,虚函数通常通过运行时动态分派实现多态。

4. 抽象机制对比

对比维度 Rust C++
行为抽象 trait 抽象类、接口式类设计
静态分派 泛型与 trait bound 模板
动态分派 dyn Trait 虚函数
代码复用 泛型、trait、组合 模板、继承、组合
继承 不支持传统类继承 支持
运算符重载 通过 trait 通过运算符重载函数
抽象约束 trait bound concepts、模板约束、继承接口

七、泛型机制的区别

泛型是两种语言实现代码复用的重要方式。

Rust 使用泛型和 trait bound;C++ 使用模板和 concepts。

1. Rust 泛型

fn add<T>(a: T, b: T) -> T
where
    T: std::ops::Add<Output = T>,
{
    a + b
}

fn main() {
    let result = add(10, 20);

    println!("{}", result);
}

这里:

  • T 是类型参数。
  • Add 是运算符对应的 trait。
  • Output = T 约束运算结果类型。
  • where 用于描述泛型约束。

2. C++ 模板

#include <iostream>

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << add(10, 20) << std::endl;
}

C++ 模板在编译阶段根据使用的类型实例化代码。

3. C++ Concepts

从 C++20 开始,C++ 引入 Concepts,用于约束模板参数。

#include <concepts>
#include <iostream>

template <typename T>
requires std::integral<T>
T add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << add(10, 20) << std::endl;
}

std::integral 限制类型参数必须满足整数类型概念。

4. 泛型机制对比

对比维度 Rust C++
泛型机制 Generics Templates
类型约束 Trait Bound Concepts、约束表达式
实例化 通常单态化 模板实例化
约束表达 trait、where concepts、requires
运算符约束 运算符 trait 运算符表达式与 concepts
泛型代码复用 支持 支持
编译错误信息 类型约束错误可能较复杂 模板实例化错误可能较复杂

两种语言都能够通过编译期泛型实现高效抽象,但模板和 trait 的语义、约束规则与实现细节不同。

八、错误处理机制的区别

Rust 与 C++ 的错误处理方式存在明显差异。

Rust 更倾向于通过类型显式表达可恢复错误,C++ 则提供异常机制,同时也可以使用错误码和结果类型。

1. Rust:Result

Rust 使用 Result<T, E> 表示可能成功也可能失败的操作。

use std::fs;

fn read_config() -> Result<String, std::io::Error> {
    let content = fs::read_to_string("config.txt")?;

    Ok(content)
}

fn main() {
    match read_config() {
        Ok(content) => {
            println!("{}", content);
        }
        Err(error) => {
            println!("Read failed: {}", error);
        }
    }
}

其中:

  • Ok(T) 表示成功。
  • Err(E) 表示失败。
  • ? 用于传播错误。
  • 调用方可以选择处理或继续向上传播错误。

2. Rust:Option

Rust 使用 Option<T> 表示可能存在或不存在的值。

fn find_user(id: u64) -> Option<String> {
    if id == 1 {
        Some("Alice".to_string())
    } else {
        None
    }
}

Option 能够将缺失值明确表达在类型中。

3. C++:异常处理

C++ 支持通过 try-catch 处理异常:

#include <iostream>
#include <stdexcept>

int divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("division by zero");
    }

    return a / b;
}

int main() {
    try {
        std::cout << divide(10, 0);
    } catch (const std::exception& error) {
        std::cout << error.what() << std::endl;
    }
}

C++ 也可以通过 std::optional 和 std::expected 等类型表达非异常结果。

其中 std::expected 从 C++23 开始进入标准库,用于表达成功值或错误值。

4. 错误处理对比

对比维度 Rust C++
可恢复错误 Result<T, E> 异常、错误码、expected
缺失值 Option<T> optional<T>
错误传播 ? throw 或显式返回
异常机制 panic! throw、try-catch
编译期约束 错误类型可纳入函数签名 异常规格不等同于 Rust Result
错误处理风格 倾向显式表达 选择较灵活

Rust 的 panic! 主要用于不可恢复错误或程序不变量被破坏等情况,不应与普通业务错误的 Result 混为一谈。

九、并发与线程安全的区别

Rust 与 C++ 都支持多线程编程,但 Rust 的突出特点是通过类型系统约束跨线程数据访问。

1. C++:线程与同步机制

C++11 起,标准库提供了完整的基础线程支持。

#include <iostream>
#include <thread>

void worker() {
    std::cout << "Worker running" << std::endl;
}

int main() {
    std::thread t(worker);

    t.join();
}

常见并发工具:

  • std::thread:创建线程。
  • std::mutex:互斥锁。
  • std::lock_guard:RAII 锁管理。
  • std::unique_lock:灵活锁管理。
  • std::atomic:原子操作。
  • std::condition_variable:条件变量。
  • std::jthread:支持自动管理和停止请求的线程类型,C++20 引入。

C++ 允许多个线程访问共享内存,但开发者需要正确使用锁、原子操作和内存序,避免数据竞争。

2. Rust:线程与所有权

Rust 使用 std::thread 创建线程。

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Worker running");
    });

    handle.join().unwrap();
}

Rust 的线程 API 会检查闭包捕获的数据是否满足跨线程传递要求。

3. Send 与 Sync

Rust 通过两个重要 trait 表达线程安全约束。

Send

表示某种类型的值可以安全地转移到另一个线程。

Sync

表示某种类型的共享引用可以安全地在线程之间传递。

简单理解:

  • Send 约束所有权跨线程转移。
  • Sync 约束共享引用跨线程访问。

例如,Arc<T> 可以实现多个线程之间的共享所有权,但如果多个线程需要修改内部数据,通常还需要结合 Mutex<T> 或其他同步机制。

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));

    let mut handles = vec![];

    for _ in 0..5 {
        let counter = Arc::clone(&counter);

        let handle = thread::spawn(move || {
            let mut value = counter.lock().unwrap();
            *value += 1;
        });

        handles.push(handle);
    }

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

    println!("{}", *counter.lock().unwrap());
}

这里:

  • Arc 提供线程安全的共享所有权。
  • Mutex 提供互斥访问。
  • move 将捕获变量的所有权移动到线程闭包中。

Send 和 Sync 可以帮助防止不安全的跨线程访问,但不会自动消除死锁、活锁或业务逻辑错误。

4. 并发安全机制对比

对比维度 Rust C++
线程创建 std::thread std::thread
互斥锁 Mutex<T> std::mutex
读写锁 RwLock<T> std::shared_mutex
原子操作 Atomic* std::atomic
线程安全约束 Send、Sync 依赖类型设计与同步规则
数据竞争 安全 Rust 中由类型系统强约束 可能产生未定义行为
共享所有权 Arc<T> std::shared_ptr<T>
内部可变性 Mutex、RwLock、Cell、RefCell 锁、原子类型和其他同步工具

十、编译与运行机制的区别

Rust 和 C++ 都通常通过编译器将源代码转换为原生机器码,但工具链和构建体系有所不同。

1. Rust 编译流程

Rust 的主要编译器是 rustc,通常使用 LLVM 作为后端之一。

flowchart TD
    A["Rust 源代码"] --> B["词法与语法分析"]
    B --> C["宏展开与名称解析"]
    C --> D["类型检查与借用检查"]
    D --> E["MIR 中间表示"]
    E --> F["代码生成"]
    F --> G["机器码与链接"]
    G --> H["原生可执行文件"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

Rust 编译阶段会进行: