Rust 中的移动语义

Question

我在 Rust 中包装了一个 C 库，它的许多函数通过指向结构的指针获取参数，这些结构本身通常具有指向其他结构的指针。为了减少开销，我想提供将 Rust 数据编组到 C 结构中的结果缓存的能力。

以下是 C 库可能需要一些参数的示例：

#[repr(C)]
struct Foo {
    x: i32,
    y: f32
}

#[repr(C)]
struct Bar {
    p_foo: *const Foo,
    z: bool
}

我想象一个拥有的“缓存”版本会是什么样子：

struct Cached {
    foo: Option<Foo>,
    bar: Bar
}

bar 的p_foo 字段将被构造为指向foo 内的Some 值，如果存在None，则为空指针。

当然，这里的问题是，如果要移动 Cached 的值，则直接的 memcpy 将不合适，并且还需要重定向 bar.p_foo。这在 C++ 中很容易确保，因为它具有可定义的移动语义，但是除了“在使用之前不要设置 bar.p_foo”之外，Rust 是否提供了解决方案？虽然这样做肯定会奏效，但我认为这些缓存值的移动频率不会超过（甚至接近于）它们被重用的频率，而且设置这些缓存值需​​要做一些工作指针，尤其是在嵌套/链接很深/很长的情况下。我也不想Box堆上的子结构。

---

为了澄清，这是我可以用 C++ 编写的，我想在 Rust 中复制：

struct Foo {
    int x;
    float y;
};

struct Bar {
    Foo const*pFoo;
    bool z;
};

// bear with me while I conjure up a Maybe for C++
class Cached {
public:
    // would have appropriate copy constructor/assignment

    Cached(Cached &&other) {
        m_foo = other.m_foo;
        m_bar = other.m_bar;

        if(m_foo.isJust()) {
            m_bar.pFoo = &m_foo.value();
        } // else already nullptr
    }

    // similar move assignment

private:
    Maybe<Foo> m_foo;
    Bar m_bar;
};

Answer 1

Rust 等价物是不使用原始指针，因为原始指针用于实现我们的安全数据结构，而不是用于实现普通数据结构。

#[repr(C)]
struct Foo {
    x: i32,
    y: f32
}

#[repr(C)]
struct Bar {
    p_foo: Option<Box<Foo>>,
    z: bool
}

只要T 是类型而不是特征，Option<Box<T>> 就保证与*const T 完全等价（以内存中的位为单位）。唯一的区别是它在 Rust 中使用是安全的。

这样你甚至不再需要Cached 结构体，而是可以直接传递Bar 对象。

---

我也不想把子结构装在堆上。

那么我建议你不要保留 Bar 对象，而是在需要将一个传递给 C 时将其变出：

#[repr(C)]
struct Foo {
    x: i32,
    y: f32
}

#[repr(C)]
struct Bar<'a> {
    p_foo: Option<&'a Foo>,
    z: bool
}

struct Cached {
    foo: Option<Foo>,
    z: bool,
}

impl Cached {
    fn bar<'a>(&'a self) -> Bar<'a> {
        Bar {
            p_foo: self.foo.as_ref(),
            z: self.z,
        }
    }
}

设置这些指针需要做一些工作，尤其是在嵌套/链接很深/很长的情况下。

这听起来很像过早优化。不要在没有进行基准测试的地方进行优化。