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