rust - 调用交换两个值的 FFI 函数的正确方法是什么？

Question

我是 Rust 的新手，我正在尝试理解它的核心概念，即所有权和借用。我已经阅读了这本书和其他一些文章，但它仍然让我感到困惑。

我有一个这样定义的结构:

#[repr(C)]
#[derive(Copy, Clone)]
pub struct Element(pub (crate) [u64; 12]);

我有一个外部函数，它根据 flag 值交换两个 Element 的值。如果 flag 为 0，则不交换它们，如果 flag 为 1，则交换它们。这就是我在原型(prototype)中使用 &mut 的原因:

extern {
    pub fn swap(x: &mut Element, y: &mut Element, flag: u8);
}

我在 Rust 中围绕这个外部函数创建了一个包装器方法:

impl for Element {
    fn wrapper_swap(&mut self, y: &mut Element, flag: u8) {
        unsafe {
            swap(self, y, flag); // OR swap(&mut self, &mut y, flag); ?!
        }
    }
}

我的wrapper_swap 函数与外部原型(prototype)函数swap 具有相同的签名。我需要如何在这里调用外部函数swap？

由于 self 和 y 已经被定义为 &mut self 和 &mut y ，我可以只调用swap 函数作为 swap(self, y, flag);?还是会删除可变引用，实际上我需要将其称为 swap(&mut self, &mut y, flag);？

对于我来说如何用实际值来调用它也变得很复杂。例如，我定义了三个这样的变量:

let mut one = Element([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
let mut two = Element([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]);
let flag: u8 = 0;

由于变量已经定义为可变的，我是否需要调用 wrapper_swap 函数作为 (&one).wrapper_swap(&two, flag); 或者这会使无论变量定义为可变，引用都是不可变的，我需要将其称为 (&mut one).wrapper_swap(&mut two, flag);？哪个是正确的方法？

也许是因为我使用了不安全的函数，但编译器并没有提示我如何调用这个函数。

如果变量 one 和 two 没有定义为可变的，会发生什么？我仍然可以借用它们作为 &mut one 或 &mut two 的可变值，并在另一个函数中更改它们的值吗？

Answer 1

您可以通过最少的探索来回答您的问题。编程时不要害怕尝试；您通常不太可能丢失任何有值(value)的东西。

例如……

build.rs

extern crate cc;

fn main() {
    cc::Build::new()
        .file("src/swap.c")
        .compile("repro");
}

src/swap.c

#include <stdio.h>
#include <stdlib.h>

void swap(int32_t *a, int32_t *b) {
  printf("Swapping %p, %p\n", a, b);

  int32_t t = *a;
  *a = *b;
  *b = t;
}

src/main.rs

extern crate libc;

use libc::int32_t;

extern "C" {
    fn swap(a: &mut int32_t, b: &mut int32_t);
}

fn swap_wrapper_1(a: &mut i32, b: &mut i32) {
    unsafe { swap(a, b) }
}

fn main() {
    let mut a = 1;
    let mut b = 2;

    swap_wrapper_1(&mut a, &mut b);
    println!("{}, {}", a, b);
}

这打印:

Swapping 0x7ffee1cf9ff0, 0x7ffee1cf9ff4
2, 1

如果您尝试使用第二种形式:

fn swap_wrapper_2(a: &mut i32, b: &mut i32) {
    unsafe { swap(&mut a, &mut b) }
}

你会收到一堆警告:

error[E0596]: cannot borrow immutable argument `a` as mutable
  --> src/main.rs:15:15
   |
14 | fn swap_wrapper_2(a: &mut i32, b: &mut i32) {
   |                   - consider changing this to `mut a`
15 |     swap(&mut a, &mut b)
   |               ^ cannot borrow mutably

如果你解决了这个问题，然后连续调用两个表单，你会得到:

Swapping 0x7ffee7483f60, 0x7ffee7483f64
2, 1
Swapping 0x7ffee7483f60, 0x7ffee7483f64
1, 2

没错——它正在交换完全相同的地址。那是因为 Rust 会 automatically dereference your value当它需要匹配签名时，只要您正确定义了 FFI 签名就没关系。