Question

我有一个C库，其接口类似于以下内容：（我已经在Rust中表示了C API，因此该问题中的所有代码都可以连接在单个.rs文件中并易于测试）

// Opaque handles to C structs
struct c_A {}
struct c_B {}

// These 2 `create` functions allocate some heap memory and other 
// resources, so I have represented this using Boxes.
extern "C" fn create_a() -> *mut c_A {
    let a = Box::new(c_A {});
    Box::into_raw(a)
}

// This C FFI function frees some memory and other resources, 
// so I have emulated that here.
extern "C" fn destroy_a(a: *mut c_A) {
    let _a: Box<c_A> = unsafe { Box::from_raw(a) };
}

extern "C" fn create_b(_a: *mut c_A) -> *mut c_B {
    let b = Box::new(c_B {});
    Box::into_raw(b)
}

// Note: While unused here, the argument `_a` is actually used in 
// the C library, so I cannot remove it. (Also, I don't control 
// the C interface)
extern "C" fn destroy_b(_a: *mut c_A, b: *mut c_B) {
    let _b = unsafe { Box::from_raw(b) };
}

我在C函数上创建了以下Rusty抽象：

struct A {
    a_ptr: *mut c_A,
}

impl A {
    fn new() -> A {
        A { a_ptr: create_a() }
    }
}

impl Drop for A {
    fn drop(&mut self) {
        destroy_a(self.a_ptr);
    }
}

struct B<'a> {
    b_ptr: *mut c_B,
    a: &'a A,
}

impl<'a> B<'a> {
    fn new(a: &'a A) -> B {
        B {
            b_ptr: create_b(a.a_ptr),
            a,
        }
    }
}

impl<'a> Drop for B<'a> {
    fn drop(&mut self) {
        destroy_b(self.a.a_ptr, self.b_ptr);
    }
}

B结构包含对A的引用，唯一的原因是在调用a_ptr函数进行内存清理时必须使用destroy_b。我的任何Rust代码都不需要该参考。

我现在想创建一个引用A和B的以下结构：

struct C<'b> {
    a: A,
    b: B<'b>,
}

impl<'b> C<'b> {
    fn new() -> C<'b> {
        let a = A::new();
        let b = B::new(&a);
        C { a, b }
    }
}

// Main function just so it compiles
fn main() {
    let c = C::new();
}

但是，它将无法编译：

error[E0597]: `a` does not live long enough
  --> src/main.rs:76:25
   |
76 |         let b = B::new(&a);
   |                         ^ borrowed value does not live long enough
77 |         C { a, b }
78 |     }
   |     - borrowed value only lives until here
   |
note: borrowed value must be valid for the lifetime 'b as defined on the impl at 73:1...
  --> src/main.rs:73:1
   |
73 | impl<'b> C<'b> {
   | ^^^^^^^^^^^^^^

我理解为什么会失败：从C返回C::new()结构时，它会移动C。这意味着包含在其中的A被移动了，这使得对其的所有引用都无效。因此，无法创建该C结构。（Explained in much more detail here）

如何重构代码，以便可以将B及其“父” A存储在结构中？我想到了一些选项，但这些选项不起作用：

更改C接口：我无法控制C接口，因此无法更改它。
已B存储了*mut c_A而不是&A：如果删除了A，则该原始指针将变为无效，并且在{{1 }}被删除。
已经B存储了自己的B而不是引用A：对于我的用例，我需要能够为每个{{ 1}}。如果&A拥有B，则每个A仅可用于创建一个B。
拥有A拥有A的所有实例，并且在创建新的B时仅返回对A的引用：这有B s的问题会随着时间的推移而累积，直到B被删除为止，将耗尽不必要的内存。但是，如果这确实是最好的解决方法，那么我可以为您带来一点不便。
使用rental板条箱：我宁愿轻取内存使用量，也不愿在代码中添加新宏的复杂性。（也就是说，任何阅读我的代码的人都需要了解此宏的工作原理，这很复杂）

我怀疑最好的解决方案是以某种方式将至少B存储在堆上，因此它不需要四处移动，但是我不知道该如何进行工作。另外，我想知道使用原始指针是否可以做些聪明的事情。

Answer 1

这听起来像是引用计数的理想情况。根据您的多线程需求使用Rc或Arc：

use std::rc::Rc;

struct B {
    b_ptr: *mut c_B,
    a: Rc<A>,
}

impl B {
    fn new(a: Rc<A>) -> B {
        B {
            b_ptr: create_b(a.a_ptr),
            a,
        }
    }
}

impl Drop for B {
    fn drop(&mut self) {
        destroy_b(self.a.a_ptr, self.b_ptr);
    }
}

fn main() {
    let a = Rc::new(A::new());
    let x = B::new(a.clone());
    let y = B::new(a);
}

不更改C接口。
A无法删除，而仍有B个引用。
可以为每个B创建多个A。
A的内存使用量不会永远增加。
创建一个堆分配来存储A及其引用计数。
Rc在标准库中，没有新的板条箱可供学习。

将来，您将可以使用任意自我类型来更好地编写此代码：

#![feature(arbitrary_self_types)]

use std::rc::Rc;

struct A {
    a_ptr: *mut c_A,
}

impl A {
    fn new() -> A {
        A { a_ptr: create_a() }
    }

    fn make_b(self: &Rc<Self>) -> B {
        B {
            b_ptr: create_b(self.a_ptr),
            a: self.clone(),
        }
    }
}

impl Drop for A {
    fn drop(&mut self) {
        destroy_a(self.a_ptr);
    }
}

struct B {
    b_ptr: *mut c_B,
    a: Rc<A>,
}

impl Drop for B {
    fn drop(&mut self) {
        destroy_b(self.a.a_ptr, self.b_ptr);
    }
}

fn main() {
    let a = Rc::new(A::new());
    let x = a.make_b();
    let y = a.make_b();
}

处理C FFI强制执行的有问题的亲子关系

1 个答案: