fb23f2906001b0f8111df9f0a4c45b8f4315b8a7
[rust-101.git] / workspace / src / part04.rs
1 // ***Remember to enable/add this part in `main.rs`!***
2
3 // Rust-101, Part 04: Ownership, Borrowing
4 // =======================================
5
6 /*
7   void foo(std::vector<int> v) {
8       int *first = &v[0];
9       v.push_back(42);
10       *first = 1337; // This is bad!
11   }
12 */
13
14 // ## Ownership
15 fn work_on_vector(v: Vec<i32>) { /* do something */ }
16 fn ownership_demo() {
17     let v = vec![1,2,3,4];
18     work_on_vector(v);
19     /* println!("The first element is: {}", v[0]); */
20 }
21
22 // ## Shared borrowing
23
24 fn vec_min(v: &Vec<i32>) -> Option<i32> {
25     use std::cmp;
26
27     let mut min = None;
28     for e in v {
29         // In the loop, `e` now has type `&i32`, so we have to dereference it to obtain an `i32`.
30         min = Some(match min {
31             None => *e,
32             Some(n) => cmp::min(n, *e)
33         });
34     }
35     min
36 }
37
38 // Now that `vec_min` does not acquire ownership of the vector anymore, we can call it multiple times on the same vector and also do things like
39 fn shared_borrow_demo() {
40     let v = vec![5,4,3,2,1];
41     let first = &v[0];
42     vec_min(&v);
43     vec_min(&v);
44     println!("The first element is: {}", *first);
45 }
46
47 // ## Mutable borrowing
48
49 fn vec_inc(v: &mut Vec<i32>) {
50     for e in v {
51         *e += 1;
52     }
53 }
54 // Here's an example of calling `vec_inc`.
55 fn mutable_borrow_demo() {
56     let mut v = vec![5,4,3,2,1];
57     /* let first = &v[0]; */
58     vec_inc(&mut v);
59     vec_inc(&mut v);
60     /* println!("The first element is: {}", *first); */
61 }
62
63 // ## Summary
64 // The ownership and borrowing system of Rust enforces the following three rules:
65 // 
66 // * There is always exactly one owner of a piece of data
67 // * If there is an active mutable borrow, then nobody else can have active access to the data
68 // * If there is an active shared borrow, then every other active access to the data is also a shared borrow
69 // 
70 // As it turns out, combined with the abstraction facilities of Rust, this is a very powerful mechanism
71 // to tackle many problems beyond basic memory safety. You will see some examples for this soon.
72