C++调用Rust的5种方式小结

// lib.rs
#[no_mangle]
pub extern "C" fn add_numbers(a: i32, b: i32) -> i32 {
    a + b  // 简单加法逻辑
}

// main.cpp
extern "C" int add_numbers(int, int);
int main() {
    return add_numbers(3, 4); // 返回7
}

extern "C" {
    void log_message(const char* msg);
    int add_numbers(int a, int b);
}

[lib]
crate-type = ["staticlib", "cdylib"]

#[no_mangle]
pub extern "C" fn add_numbers(a: i32, b: i32) -> i32 {
    a + b
}

// 将字符串与基本类型封装为安全结构体
type SafeData struct {
    Value string `json:"value"`
    Type  string `json:"type"` // "int", "float", "bool"
}

// 序列化前验证类型一致性
func EncodeBasicType(v interface{}) (string, error) {
    var data SafeData
    switch val := v.(type) {
    case int:
        data = SafeData{Value: fmt.Sprintf("%d", val), Type: "int"}
    case bool:
        data = SafeData{Value: fmt.Sprintf("%t", val), Type: "bool"}
    default:
        return "", errors.New("unsupported type")
    }
    jsonBytes, _ := json.Marshal(data)
    return string(jsonBytes), nil
}

int write_data(int fd, const char* buf, size_t len);
// 返回0表示成功，-1表示失败，错误原因存储于全局errno

[lib]
crate-type = ["cdylib"]

[dependencies]
aes-gcm = "0.10"

use aes_gcm::{Aes256Gcm, Key, Nonce};
use std::os::raw::c_uchar;

#[no_mangle]
pub extern "C" fn encrypt(
    key: *const c_uchar,
    nonce: *const c_uchar,
    plaintext: *const c_uchar,
    plaintext_len: usize,
    ciphertext: *mut c_uchar,
) -> bool {
    // 安全解引用指针并执行加密
}

let data = Box::new(42);
let raw_ptr = Box::into_raw(data); // 转移所有权至 C++
// 传递 raw_ptr 给 C++，由 C++ 负责释放

class FileHandle {
    FILE* fp;
public:
    explicit FileHandle(const char* path, const char* mode) {
        fp = fopen(path, mode);
        if (!fp) throw std::runtime_error("Cannot open file");
    }
    ~FileHandle() { if (fp) fclose(fp); }
    FILE* get() const { return fp; }
};

//export RetainObject
func RetainObject(handle uintptr) {
    obj := handleToObject[handle]
    obj.RefCount++
}
//export ReleaseObject
func ReleaseObject(handle uintptr) {
    obj := handleToObject[handle]
    obj.RefCount--
    if obj.RefCount == 0 {
        delete(handleToObject, handle)
        freeCMemory(obj.CPtr) // 释放C侧内存
    }
}

extern "C" void register_callback(void (*cb)(int)) {
    // 存储函数指针
    g_callback = cb;
}

extern "C" fn rust_callback(value: i32) {
    println!("Received from C++: {}", value);
}

extern "C" {
    Object* create_object();
    void call_method(Object* obj);
    void destroy_object(Object* obj);
}

extern "C" {
    fn create_object() -> *mut c_void;
    fn call_method(obj: *mut c_void);
    fn destroy_object(obj: *mut c_void);
}

// Go 发布者示例
conn, _ := amqp.Dial("amqp://guest:guest@localhost:5672/")
ch, _ := conn.Channel()
ch.Publish(
  "events_exchange", // 交换机名
  "user.created",    // 路由键
  false, false,
  amqp.Publishing{
    ContentType: "application/json",
    Body:        []byte(`{"id":1,"name":"Alice"}`),
  })

#[no_mangle]
pub extern "C" fn parse_log_entry(raw: *const u8, len: usize) -> LogParseResult {
    // 安全地从C指针构建切片
    let data = unsafe { std::slice::from_raw_parts(raw, len) };
    // 使用nom进行零拷贝解析
    match log_parser(data) {
        Ok((_, parsed)) => LogParseResult::success(parsed.level, parsed.msg),
        Err(_) => LogParseResult::failure(),
    }
}

// 使用轻量级日志中间件替代 full-stack logger
func LightweightLogger() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        c.Next()
        // 仅记录关键指标
        log.Printf("%s %s %v", c.Request.Method, c.Request.URL.Path, time.Since(start))
    }
}