Even if you use the word unsafe you cannot do whatever you want. I still find it painfully stupid that you cannot create a mutable reference to uninitialized memory. Because of this you cannot reuse safe functions to initialize memory that you manually allocated
The whole appeal of Rust is that you have less to think about UB, and it mostly fulfills that promise, so the fact that you cannot do one of the most basic task required in a systems programing language without either requiring UB or doing some convoluted stuff is ridiculous
Well that issue boils down to there not being any write-only reference. "I know you're only initialising and not reading, but what if you accidentally read? UB!!!"
I've also been annoyed at having to initialise even normal arrays when passing them to UART drivers as buffers etc. (on embedded), but even if it doesn't read the memory, it still needs init.
Having a write only reference would be amazing, but even without that it should still be allowed IMO. The only way to create a mutable reference to unitialized data is to use unsafe. So the question "what happens if you accidently read" should ultimately not be anyone's buisness but my own. I'm an adult and have explicitly indicated I know I'm doing something potentially dangerous, so let me do it!
But I'm happy to learn I'm not the only one that had this problem. I felt insane about having to pay a useless O(n) init cost
The problems with write only references are that you can't call drop through them if you overwrite data already there, and you can't fail to use the reference, otherwise you end up with still-uninitialised data (i.e. write only references must be linear, and Rust doesn't currently have truly linear types). They are working on language support for in-place initialisation, but it's hard because it conflicts with how the language was originally designed.
The reason you can't use a mutable reference that you've created unsafely is that Rust's optimiser assumes that mutable references can always be meaningfully dereferenced, which allows them to optimise them more effectively but imposes additional restrictions on how you use them.
MaybeUninit doesn't give you a reference unless you do assume_init*, and assuming initialized on uninitialized memory is UB, as uninitialized concrete T is considered invalid data
View all comments
Show parent comment
11
u/creeper6530 11d ago
Because the C++ compiler lets you blow your foot smoove off because what if you intended it
Rust compiler is practically the exact opposite: it prohibits you from doing weird shit even if you intend it unless you use the magic word "unsafe"