I wanted to have a Option<Box<Other>>
and access to the underlying boxed value. I'm currently holding a Option<*mut Other>
, which though won't have pointed memory released after anon_box.into_raw()
(where anon_box = Box::new(other)
), as the docs recommends to construct another box back with Box::from_raw()
. So is there something phantom for not leaking heap memory?
If you want to turn the Box<T>
into a pointer, then you can use into_raw
and then from_raw
once you're done with the pointer to drop the underlying value
But it will drop earlier since the box won't be in my longer-living struct. Or maybe I should do that in Drop
explictly.
Why do you need a Option<Box<Other>>
rather than, e.g., a Option<&mut Other>
? If your long-lived struct is what actually owns the allocation behind the raw pointer, then you shouldn't try to create a Box
from that allocation in other places. Keep the raw ptr there, and deallocate it in the long lived struct's Drop
impl.
Truly I was referring to another struct, DisplayElement
, which wraps it (Other
) and holds other fields. Right, if Other
were longer, then I could borrow it; but instead it's owned by DisplayElement
. The issue is since I want an optional Other
, so that not all elements need to store additional fields (a.k.a. advanced fields).
I'm in a phone and I may install Termux later to check if it'll work to implement the Drop
trait.
Can you provide an example of what you're trying to achieve on the Rust playground, or at least sketch out some code here?
It's a bit hard to tell what exactly is the problem. I also don't quite understand why you need a *mut Other
raw pointer to begin with - is there a reason DisplayElement
can't store an Option<Other>
or Option<Box<Other>>
(if you want/need Other
on the heap)? So DisplayElement
owns the Other
- who else needs to use/borrow this Other
? More elaboration would help, as mentioned.
I'm in phone and that's true. Well, here's a code: Rust Playground
I thought it'd fail with Box
. In my real code I'm using a Cell
, but once I used it with Rc (Cell<Option<Rc<Advanced>>>
) and it didn't compile. So it looks like I may not need to use the raw pointer, but I'm afraid it won't compile complaining about Copy.
I don't think you need the Cell
wrapper. It seems you can just use something like:
struct DisplayElem {
other: Option<Rc<Other>>,
}
struct Other {
pub alpha: Cell<u8>,
pub scale_x: Cell<f64>,
pub scale_y: Cell<f64>,
}
I'm assuming here that you actually want the Rc
over Other
, and that you want interior mutability over the individual fields of Other
.
With the above, your example becomes this.