This is a use-after-free, which should be impossible in safe Rust due to the borrow checker. The only way for this to happen would be incorrect unsafe code (still possible, but dramatically reduced code surface to worry about) or a compiler bug. To allocate heap space in safe Rust, you have to use types provided by the language like Box, Rc, Vec, etc. To free that space (in Rust terminology, dropping it by using drop() or letting it go out of scope) you must be the owner of it and there may be current borrows (i.e. no references may exist). Once the variable is droped, the variable is dead so accessing it is a compiler error, and the compiler/std handles freeing the memory.
There’s some extra semantics to some of that but that’s pretty much it. These kind of memory bugs are basically Rust’s raison d’etre - it’s been carefully designed to make most memory bugs impossible without using unsafe. If you’d like more information I’d be happy to provide!
Thanks for the response. Ive heard of rust’s compiler being very smart and checking a ton of stuff. Its good thing it does, but i feel like there are things that can cause this issues rust cant catch. Cant put my finger on it.
What would rust do if you have a class A create something on the heap, and it passes this variable ( by ref ? ) to class B, which saves the value into a private variable in class B. Class A gets out of scope, and would be cleaned up. What it put on the heap would be cleaned up, but class B still has a reference(?) to the value on the heap, no? How would rust handle such a case?
Rust simply doesn’t allow you to have references to data that goes out of scope (unless previously mentioned hoops are jumped through such as an explicitly declared unsafe block). It’s checked at compile time. You will never be able to compile the program.
Rust isn’t C. Rust isn’t C++. The memory-safe-ness of it is also not magic, it’s a series of checks in the compiler.
That sounds odd. That also means that a mapper, command, service,… can never return a class object or entity. Most of the programming world is based on oop o.O
Keep in mind im not talking about the usage of pointers, but reference typed variables.
Oh sure, I’m still learning so I thought you meant references as in pointers like in C++. But also, Rust isn’t a strictly object oriented language either. It shares a lot of similar features, but they aren’t all the typical way you’d do things in an OOP language. You should check out the chapter of the Rust book for ownership.
This is a use-after-free, which should be impossible in safe Rust due to the borrow checker. The only way for this to happen would be incorrect unsafe code (still possible, but dramatically reduced code surface to worry about) or a compiler bug. To allocate heap space in safe Rust, you have to use types provided by the language like
Box,Rc,Vec, etc. To free that space (in Rust terminology, dropping it by usingdrop()or letting it go out of scope) you must be the owner of it and there may be current borrows (i.e. no references may exist). Once the variable isdroped, the variable is dead so accessing it is a compiler error, and the compiler/std handles freeing the memory.There’s some extra semantics to some of that but that’s pretty much it. These kind of memory bugs are basically Rust’s raison d’etre - it’s been carefully designed to make most memory bugs impossible without using
unsafe. If you’d like more information I’d be happy to provide!Thanks for the response. Ive heard of rust’s compiler being very smart and checking a ton of stuff. Its good thing it does, but i feel like there are things that can cause this issues rust cant catch. Cant put my finger on it.
What would rust do if you have a class A create something on the heap, and it passes this variable ( by ref ? ) to class B, which saves the value into a private variable in class B. Class A gets out of scope, and would be cleaned up. What it put on the heap would be cleaned up, but class B still has a reference(?) to the value on the heap, no? How would rust handle such a case?
Rust simply doesn’t allow you to have references to data that goes out of scope (unless previously mentioned hoops are jumped through such as an explicitly declared unsafe block). It’s checked at compile time. You will never be able to compile the program.
Rust isn’t C. Rust isn’t C++. The memory-safe-ness of it is also not magic, it’s a series of checks in the compiler.
That sounds odd. That also means that a mapper, command, service,… can never return a class object or entity. Most of the programming world is based on oop o.O
Keep in mind im not talking about the usage of pointers, but reference typed variables.
Oh sure, I’m still learning so I thought you meant references as in pointers like in C++. But also, Rust isn’t a strictly object oriented language either. It shares a lot of similar features, but they aren’t all the typical way you’d do things in an OOP language. You should check out the chapter of the Rust book for ownership.