Rustがメモリセーフである理由②（参照を理解する）

fn main() {
    let s1 = String::from("hello");
    
    // calculate_lengthに引数としてs1を渡した時点でs1の所有権は無効になる
    // そのため、s1をs2に渡すことで同じ文字列の使用を可能にする
    let (s2, len) = calculate_length(s1);
    println!("The length of '{}' is {}.", s2, len);
}

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len();
    (s, length)
}

fn main() {
    let s1 = String::from("hello");

    // s1の参照である&s1を関数に渡すことでs1の所有権は有効のままである
    // そのため、s1はcalculate=length()が呼ばれた後も使用可能となる
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len);
}

// 引数の型はString型の参照である&Stringとなる
// 関数の引数に参照を取ること（今回であれば&Stringを取ること）を借用と呼ぶ
fn calculate_length(s: &String) -> usize {
    s.len()
}

fn main() {
    // 可変な文字列であるs1を生成する
    let mut s1 = String::from("hello");

    // push_worldに可変な参照としてs1を渡す
    push_world(&mut s1);
    println!("{}", s1);
}

// push_worldは可変な参照としてsを受け取る
fn push_world(s: &mut String) {
    s.push_str(", world")
}

fn main() {
    let mut s =String::from("hello");

    let r1 = &mut s;
    // 変数sに対して二つ目の可変な参照であるr2を生成しようとしている
    let r2 = &mut s;
    println!("{},{}",r1,r2);
}

error[E0499]: cannot borrow `s` as mutable more than once at a time
 --> src/main.rs:5:14
  |
4 |     let r1 = &mut s;
  |              ------ first mutable borrow occurs here
5 |     let r2 = &mut s;
  |              ^^^^^^ second mutable borrow occurs here
6 |
7 |     println!("{}, {}", r1, r2);
  |                        -- first borrow later used here

fn main() {
    let mut s = String::from("hello");

    let r1 = &s;
    let r2 = &mut s;

    println!("{},{}", r1, r2);
}

error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
 --> src/main.rs:5:14
  |
4 |     let r1 = &s;
  |              -- immutable borrow occurs here
5 |     let r2 = &mut s;
  |              ^^^^^^ mutable borrow occurs here
6 |
7 |     println!("{},{}", r1, r2);
  |                       -- immutable borrow later used here

fn main() {
    let mut s = String::from("hello world");

    // wordはsの参照をとる
    let word = first_word(&s);
    println!("the first word is: {}", word);
}

// 文字列スライスの型は&strであるため、戻り値の型を&strと定義する
fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            // 戻り値としてsの部分的な参照（文字列スライス）を返す
            return &s[0..i];
        }
    }
   
    // 文字列スライスとして、文字列の一部ではなく全てを返すこともできる
    &s[..]
}