rust - ps4 - Estructura con cortes que apuntan a datos en sí mismos

rust traduccion

Question

Tengo una estructura

struct Foo<''a> {
    buf: [u8, ..64],
    slice: &''a [u8]
}

La porción se supone que apunta al campo buf de la estructura. ¿Hay alguna forma de construir tal estructura? Algo como:

impl<''a> Foo<''a> {
    fn new() -> Foo<''a> {
        Foo {
            buf: [0, ..64],
            slice: ???? /* I don''t know what to write here */
    }
}

Si trato de hacer algo como lo siguiente, el comprobador de préstamos se queja (correctamente), ya que el segmento tendrá una vida más corta que la estructura.

impl<''a> Foo<''a> {
    fn new() -> Foo<''a> {
        let buf = [0, ..64];
        Foo {
            buf: buf,
            slice: buf.slice_from(0)
        }
    }
}

Me doy cuenta de que para este caso simple podría mantener las compensaciones y llamar manualmente las funciones de división:

struct Foo {
    buf: [u8, ..64],
    slice_from: uint,
    slice_to: uint
}

Sin embargo, esta pregunta es solo una simplificación de un caso de uso más general de una estructura que posee datos y tiene referencias en los mismos datos y me pregunto si eso es posible (de manera segura) en Rust.

Answer 1

No, no puede hacerlo de manera segura, porque en general tal estructura no es movible. Haga de cuenta que es posible, y puede crear esa estructura:

let foo = Foo {
    buf: [0, ..64],
    slice: obtain_slice_somehow()
};

El campo de slice ahora es una porción de campo buf , en particular, contiene un puntero a buf , que actualmente se encuentra en la pila. Ahora coloca foo en una caja y regresa de la función:

return Box::new(foo);

foo valor foo ahora se mueve a Heap, y la función sale, liberando su memoria de pila. Sin embargo, el puntero de slice no se ajusta para apuntar a montón, porque es imposible de hacer en general, y por lo tanto se dejó colgando, violando la seguridad de la memoria.