C++的shared_ptr怎么和rust交互？

C++ 中的 `shared_ptr` 和 Rust 中的 `Rc`、`Arc` 都是智能指针，可以用于内存管理，但是由于语言不同，它们在底层实现上有很大的差异，因此在 C++ 和 Rust 之间交互时需要特别注意。

要在 C++ 和 Rust 之间交互 `shared_ptr`，可以使用 `cxx` 库进行绑定。具体来说，我们需要在 C++ 中将 `shared_ptr` 转换为 `void*`，然后将其传递给 Rust，Rust 再将 `void*` 转换为 `Rc` 或者 `Arc`。

以下是一个简单的例子，演示了如何在 C++ 和 Rust 之间交互 `shared_ptr`：

C++ 代码：

#include <memory>
#include <iostream>
#include <cxxbridge/cxx.h>

struct Foo {
    int x;
    Foo(int x) : x(x) {}
    void hello() {
        std::cout << "Hello from Foo(" << x << ")!\n";
    }
};

std::shared_ptr<Foo> make_foo(int x) {
    return std::make_shared<Foo>(x);
}

void use_foo(std::shared_ptr<Foo> ptr) {
    ptr->hello();
}

void* get_raw_ptr(std::shared_ptr<Foo> ptr) {
    return (void*) ptr.get();
}

CXX_EXPORT void cxxbridge_demo_run() {
    auto foo = make_foo(42);
    use_foo(foo);
    void* raw_ptr = get_raw_ptr(foo);
    // 将 void* 指针传递给 Rust
    rust_use_shared_ptr(raw_ptr);
}

Rust 代码：

use std::rc::Rc;
use std::cell::RefCell;
use std::ffi::c_void;

struct Foo {
    x: i32,
}

impl Foo {
    fn new(x: i32) -> Self {
        Self { x }
    }

    fn hello(&self) {
        println!("Hello from Foo({})!", self.x);
    }
}

// 用于从 void* 指针构造 Rc 智能指针
fn from_raw_ptr<T>(ptr: *mut c_void) -> Rc<T> {
    unsafe { Rc::from_raw(ptr as *const T as *mut T) }
}

// 用于从 Rc 智能指针构造 void* 指针
fn to_raw_ptr<T>(rc: Rc<T>) -> *mut c_void {
    Rc::into_raw(rc) as *mut c_void
}

// 用于接收 C++ 中传递的 shared_ptr 指针
#[no_mangle]
extern "C" fn rust_use_shared_ptr(ptr: *mut c_void) {
    let rc = from_raw_ptr::<Foo>(ptr);
    rc.hello();
}

fn main() {
    let foo = Rc::new(Foo::new(42));
    let ptr = to_raw_ptr(foo.clone());
    unsafe {
        // 将 Rc 智能指针指向的内存传递给 C++
        cpp_use_shared_ptr(ptr);
    }
}

// 用于调用 C++ 中的函数，并传递 Rc 智能指针指向的内存
#[link(name = "cxxbridge_demo")]
extern "C" {
    fn cpp_use_shared_ptr(ptr: *mut c_void);
}

在这个例子中，我们定义了一个 `Foo` 类和两个函数 `make_foo` 和 `use_foo`，它们分别用于创建 `shared_ptr` 类型的对象和使用 `shared_ptr` 类型的对象。我们还定义了一个 `get_raw_ptr` 函数，它可以将 `shared_ptr` 转换为 `void*`，方便在 C++ 和 Rust 之间传递。

在 Rust 代码中，我们定义了一个 `Foo` 结构体，并实现了 `from_raw_ptr` 和 `to_raw_ptr` 函数，用于将 `void*` 指针和 `Rc` 智能指针进行转换。在 `main` 函数中，我们创建一个 `Rc` 智能指针，然后将其指向的内存传递给 C++ 中的 `cpp_use_shared_ptr` 函数。在 `rust_use_shared_ptr` 函数中，我们将 `void*` 指针转换为 `Rc` 智能指针，并使用其调用 `hello` 方法。

最后，我们需要使用 `cxx` 将 C++ 和 Rust 代码进行绑定。具体来说，我们需要在 C++ 代码中使用 `CXX_EXPORT` 宏将 `cxxbridge_demo_run` 函数导出为 C 风格的函数，然后在 Rust 代码中使用 `extern "C"` 关键字声明该函数。同时，我们还需要在 Rust 代码中使用 `#[link(name = "cxxbridge_demo")]` 注解来链接 C++ 库。