Structs with slices pointing to data in themselves

Question

I have a struct

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

The slice is supposed to point into the buf field of the struct. Is there any way to construct such a struct? Something like:

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

If I try to do something like the following, the borrow checker complains (correctly), since the slice will have a shorter lifetime than the struct.

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

I realize that for this simple case I could keep offsets and manually call the slice functions:

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

However this question is just a simplification of a more general use case of a struct owning data and having references into the same data and I'm wondering if that is possible (in a safe way) in Rust.

I have asked a similar question (http://stackoverflow.com/questions/27092273/how-to-make-a-struct-where-one-of-the-fields-refers-to-another-field) and unfortunately it seems like there is no safe way to do this. — fjh, Dec 04 '14 at 13:51

score 10 · Accepted Answer · edited Aug 13 '17 at 14:05

10

No, you can't do it safely, because in general such a structure is not movable. Pretend it is possible, and you can create such a structure:

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

The slice field is now a slice of buf field, in particular, it contains a pointer to buf, which is currently located on the stack. Now put foo into a box and return it from the function:

return Box::new(foo);

foo value is now moved to heap, and the function exits, freeing its stack memory. However, slice pointer is not adjusted to point to heap, because it is impossible to do in general, and so it left dangling, violating memory safety.

edited Aug 13 '17 at 14:05

Shepmaster

388,571
95
1,107
1,366

answered Dec 04 '14 at 15:14

Vladimir Matveev

120,085
34
287
296

1

I understand. However, what if buf was a Vec? Then the pointer would always be on the heap and wouldn't become invalid even if foo was moved. – dnaq Dec 04 '14 at 20:28
I just realized that the vec can of course reallocate as it grows, causing the old pointer in the slice to become invalid. However, it seems to be possible to fool the borrow checker by doing something like that. I might add another question pertaining to that though. – dnaq Dec 04 '14 at 20:58
@dnaq, I doubt that it is possible to fool the borrow checker :) If you're able to, it is most certainly a bug in rustc. – Vladimir Matveev Dec 05 '14 at 03:25
1

I was able to fool the borrow checker, the bug report is [here](https://github.com/rust-lang/rust/issues/19537) and the associated reddit post is [here](http://www.reddit.com/r/rust/comments/2oappt/fooling_the_borrow_checker_bug/). – dnaq Dec 05 '14 at 09:42

Structs with slices pointing to data in themselves

1 Answers1

Linked