¿Cuál es el idioma de Rust para definir un campo que apunta a un puntero opaco en C?

Question

Dada una estructura:

#[repr(C)]
pub struct User {
pub name: *const c_char,
pub age: u8,
pub ctx: ??,
}

el campo ctx solo sería manipulado por el código C; es un puntero a un C struct UserAttr .

De acuerdo con la documentación de Rust FFI , la elección se definiría como un tipo opaco pub enum UserAttr {} . Sin embargo, descubrí que Rust no puede copiar su valor, por ejemplo, ¿ por qué la dirección de un objeto cambia a través de los métodos ?

¿Cuál es la forma correcta en Rust de definir un puntero tan opaco, para que su valor (como puntero) se copie entre los métodos?

Answer 1

El futuro

RFC 1861 introdujo el concepto de un tipo externo . Mientras está implementado, aún no está estabilizado. Una vez que sea así, se convertirá en la implementación preferida:

#![feature(extern_types)]
extern "C" {
type Foo;
}
type FooPtr = *mut Foo;

Hoy

La documentación dice:

Para hacer esto en Rust, creemos nuestros propios tipos opacos:

#[repr(C)] pub struct Foo { private: [u8; 0] }
#[repr(C)] pub struct Bar { private: [u8; 0] }
extern "C" {
pub fn foo(arg: *mut Foo);
pub fn bar(arg: *mut Bar);
}

Al incluir un campo privado y ningún constructor, creamos un tipo opaco que no podemos instanciar fuera de este módulo. Una matriz vacía es de tamaño cero y compatible con #[repr(C)] . Pero debido a que nuestros tipos Foo y Bar son diferentes, obtendremos seguridad de tipo entre los dos, por lo que no podemos pasar accidentalmente un puntero a Foo a bar() .

Se crea un puntero opaco de manera que no haya una forma normal de crear dicho tipo; solo puedes crearle punteros.

mod ffi {
use std::ptr;
pub struct MyTypeFromC { _private: [u8; 0] }
pub fn constructor() -> *mut MyTypeFromC {
ptr::null_mut()
}
pub fn something(_thing: *mut MyTypeFromC) {
println!("Doing a thing");
}
}
use ffi::*;
struct MyRustType {
score: u8,
the_c_thing: *mut MyTypeFromC,
}
impl MyRustType {
fn new() -> MyRustType {
MyRustType {
score: 42,
the_c_thing: constructor(),
}
}
fn something(&mut self) {
println!("My score is {}", self.score);
ffi::something(self.the_c_thing);
self.score += 1;
}
}
fn main() {
let mut my_thing = MyRustType::new();
my_thing.something();
}

Desglosándolo un poco:

// opaque -----V~~~~~~~~~V
*mut MyTypeFromC
// ^~~^ ------------ pointer

Por lo tanto, es un puntero opaco. Mover la estructura MyRustType no cambiará el valor del puntero.

El pasado

Las iteraciones anteriores de esta respuesta y la documentación sugerían usar una enumeración vacía ( enum MyTypeFromC {} ). Una enumeración sin variantes es semánticamente equivalente al tipo nunca ( ! ), Que es un tipo que no puede existir. Existía la preocupación de que el uso de tal construcción podría conducir a un comportamiento indefinido, por lo que pasar a una matriz vacía se consideró más seguro.