Rust - Ownership & Borrowing

Introduction to Rust ownership and borrowing concepts.

Transcript

1. Rust Rust Onwership & Onwership & Borrowing Borrowing
2. Stack vs Heap Stack vs Heap Stack Stack fast automatically desaclocated at scope end limited size pointers and primitives storage
3. Heap Heap slower manage memory allocation
4. Control vs Security Control vs Security Control : optimisation Security : avoid memory allocation problems / memory leaks
5. Examples Examples allocating memory and never free it dangling pointers keep a reference to freed memory have a reference to a moved variable (realloc) other problems...
6. Examples in C++ Examples in C++
7. Examples in C++ Examples in C++
8. Examples in C++ Examples in C++
9. Rust Rust manage desallocation at compile time avoid alias & mutability at same time
10. Rust Rust Ownership Ownership
11. What happens when What happens when variable is copied variable is copied primitives : stack copy others : "move" String example copy stack representation : pointer, length, capacity disable rst variable -> 'value used here after move'
12. Take Ownership Take Ownership copy variable into another variable pass variable to function return variable from function
13. Keep Ownership after Keep Ownership after function call function call send inputs as outputs
14. Clone Clone deep copy : stack + heap never done automaticaly by rust done automaticaly by rust for Stack only data (@see Copy trait) : integers, boolean, oat, character, tuple of these types
15. Borrowing Borrowing Borrow a variable Keep ownership
16. : Reference : Reference
17. Borrowing : 2 ways Borrowing : 2 ways fn(val: &String) no mutability any borrow as you want fn(val: &mut String) mutable other constraints
18. Mutable Reference Mutable Reference cannot make a mutable reference if an immutable reference has been done
19. Mutable Reference Mutable Reference cannot make multiple mutables references avoid data race
20. String case String case String : stored in the heap &String : reference to a String &str : slice from a String &'static str : slice : stored in program
21. String case : &str String case : &str
22. world name value ptr len 5 index value 0 h 1 e 2 l 3 l 4 o 5 6 w 7 o 8 r 9 l 10 d s name value ptr len 11 capacity 11
23. String case String case as function parameter ? If we don't need ownership -> &str fn example(value : &str) { println!(value); }
24. String case String case as function parameter ? If we need owership -> String fn example($self, value : String) { self.value = value; }
25. String case String case &str : if the variable must be used outside my struct/fn &str : if the variable should be large : avoid deep copy
26. Useful traits Useful traits Box : store data on the heap Deref : &String -> &str Rc : data owned by multiple variable Mutex Into Cow
27. References References 2014 : Memory Safety in Rust : Intro : String vs &str : https://www.youtube.com/watch? v=WQbg6ZMQJvQ http://intorust.com/ https://hermanradtke.com/2015/05/03/string-vs- str-in-rust-functions.html