Rust C++互操作库autocxx的使用：安全高效实现Rust与C++代码的无缝集成

简介

autocxx 是一个用于 Rust 和 C++ 互操作的库，旨在提供安全、高效的绑定生成。它通过解析 C++ 头文件自动生成 Rust 绑定，大大简化了 Rust 调用 C++ 代码的过程。

主要特性

1. 自动化绑定生成：通过解析 C++ 头文件自动生成 Rust 接口
2. 类型安全：生成的绑定尽可能保证类型安全
3. 零成本抽象：生成的代码高效，几乎没有运行时开销
4. 支持现代 C++：支持许多 C++11 及更高版本特性

完整示例代码

项目结构

autocxx-demo/
├── Cargo.toml
├── build.rs
├── src/
│   ├── example.cpp
│   ├── example.h
│   ├── ffi.rs
│   └── main.rs

1. Cargo.toml

[package]
name = "autocxx-demo"
version = "0.1.0"
edition = "2021"

[build-dependencies]
autocxx-build = "0.25"

[dependencies]
autocxx = "0.25"

2. build.rs

use autocxx_build::Builder;

fn main() {
    Builder::new("src/ffi.rs", &["src/"])
        .build()
        .unwrap()
        .compile("autocxx-demo");
    println!("cargo:rerun-if-changed=src/ffi.rs");
}

3. src/example.h (C++头文件)

#pragma once

#include <string>
#include <vector>
#include <functional>

// 简单C++类示例
class MyCppClass {
public:
    MyCppClass(int value);
    ~MyCppClass();
    
    int get_value() const;
    void set_value(int value);
    
private:
    int value_;
};

// 处理复杂类型的类
class DataProcessor {
public:
    std::vector<std::string> process(const std::vector<int>& input);
};

// 回调函数示例
class CallbackHandler {
public:
    void set_callback(std::function<void(int)> callback);
    void trigger(int value);
};

4. src/example.cpp (C++实现)

#include "example.h"
#include <algorithm>

// MyCppClass实现
MyCppClass::MyCppClass(int value) : value_(value) {}
MyCppClass::~MyCppClass() = default;

int MyCppClass::get_value() const { return value_; }
void MyCppClass::set_value(int value) { value_ = value; }

// DataProcessor实现
std::vector<std::string> DataProcessor::process(const std::vector<int>& input) {
    std::vector<std::string> result;
    for (int num : input) {
        result.push_back(std::to_string(num * 2));
    }
    return result;
}

// CallbackHandler实现
void CallbackHandler::set_callback(std::function<void(int)> callback) {
    callback_ = callback;
}

void CallbackHandler::trigger(int value) {
    if (callback_) {
        callback_(value);
    }
}

5. src/ffi.rs (Rust绑定)

use autocxx::include_cpp;

include_cpp! {
    #include "example.h"
    safety!(unsafe_ffi)
    generate!("MyCppClass")
    generate!("DataProcessor")
    generate!("CallbackHandler")
    generate_pod!("std::vector<int>")
    generate_pod!("std::string")
    generate_pod!("std::vector<std::string>")
}

6. src/main.rs (Rust主程序)

mod ffi;

fn main() {
    // 简单C++类使用示例
    println!("=== Simple C++ Class Demo ===");
    let mut obj = ffi::MyCppClass::new(42).within_unique_ptr();
    println!("Initial value: {}", obj.get_value());
    obj.pin_mut().set_value(100);
    println!("New value: {}", obj.get_value());

    // 复杂类型处理示例
    println!("\n=== Complex Type Demo ===");
    let processor = ffi::DataProcessor::new().within_unique_ptr();
    let input = vec![1, 2, 3];
    let output = processor.process(&input);
    println!("Processed: {:?}", output);

    // 回调函数示例
    println!("\n=== Callback Demo ===");
    let handler = ffi::CallbackHandler::new().within_unique_ptr();
    handler.pin_mut().set_callback(|value| {
        println!("Callback triggered with value: {}", value);
    });
    handler.pin_mut().trigger(42);
}

构建和运行

1. 确保已安装Rust工具链和C++编译器
2. 在项目目录下运行:

cargo build
cargo run

注意事项

1. 确保C++代码编译为与Rust兼容的ABI
2. 使用within_unique_ptr()来管理C++对象生命周期
3. 修改C++头文件后需要重新构建项目
4. 复杂项目可能需要额外的构建配置

这个完整示例演示了autocxx的主要功能，包括简单类使用、复杂类型处理和回调函数。你可以根据需要扩展这个基础框架。