{
    let s = String::from("hello"); // s is valid from this point forward
    println!("{}", s);
}                              // this scope is now over, and s is no longer valid

// 【C言語】
char *sora = malloc(1); 　// メモリ確保
free(sora);                  　　  　// メモリ解放

sora;                            　　 　 // 既にダングリングポインタ
*sora = 'dangling';　         // ダングリングポインタへのアクセス

{                                // sはまだ宣言されていない
    let s = "sora";     // sを宣言
    println!("{}", s);  // sが
}                                // このスコープは終わり。もうsは有効ではない

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

s.push_str(", world!"); // push_str() appends a literal to a String

println!("{}", s); // This will print `hello, world!`

{                                // sはまだ宣言されていない
    let s = "sora";     // sを宣言
    println!("{}", s);  // sが
}                                // このスコープは終わり。もうsは有効ではない

{
    let s = String::from("hello"); // s is valid from this point forward
    println!("{}", s);
}                                                   // this scope is now over, and s is no
                                                    // longer valid

let x = 5;
let y = x;

let s1 = String::from("hello");
let s2 = s1;

let s1 = String::from("hello");
let s2 = s1;

println!("{}, world!", s1);

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0382]: borrow of moved value: `s1`
 --> src/main.rs:5:28
  |
2 |     let s1 = String::from("hello");
  |         -- move occurs because `s1` has type `std::string::String`, which does not implement the `Copy` trait
3 |     let s2 = s1;
  |              -- value moved here
4 | 
5 |     println!("{}, world!", s1);
  |                            ^^ value borrowed here after move

error: aborting due to previous error

For more information about this error, try `rustc --explain E0382`.
error: could not compile `ownership`.

To learn more, run the command again with --verbose.

let s1 = String::from("hello");
let s2 = s1.clone();

println!("s1 = {}, s2 = {}", s1, s2);

let x = 5;
let y = x;

println!("x = {}, y = {}", x, y);

fn main() {
    let s = String::from("hello");  // s comes into scope

    takes_ownership(s);             // s's value moves into the function...
　　　　　　　　　　　　　　　                                    // ... and so is no longer valid here

    println!("{}", s);                     // ← エラーになる
}

fn takes_ownership(some_string: String) { // some_string comes into scope
    println!("{}", some_string);
} // Here, some_string goes out of scope and `drop` is called. The backing
  // memory is freed.

fn main() {
    let x = 5;                      // x comes into scope

    makes_copy(x);                  // x would move into the function,
                                    // but i32 is Copy, so it’s okay to still
                                    // use x afterward

    println!("{}", x);    // エラーにならない
}

fn makes_copy(some_integer: i32) { // some_integer comes into scope
    println!("{}", some_integer);
} // Here, some_integer goes out of scope. Nothing special happens.

fn main() {
    let x = 5;                      // x comes into scope

    makes_copy(x);                  // x would move into the function,
                                    // but i32 is Copy, so it’s okay to still
                                    // use x afterward

    println!("{}", x);    // エラーにならない
}

fn makes_copy(some_integer: i32) { // some_integer comes into scope
    println!("{}", some_integer);
} // Here, some_integer goes out of scope. Nothing special happens.

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

    let len = calculate_string_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_string_length(s: &String) -> usize {
    s.len()
}

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

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

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

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

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

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

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

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

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

{
    let r1 = &mut s;

} // r1 goes out of scope here, so we can make a new reference with no problems.

let r2 = &mut s;

fn first_word(s: &String) -> usize {
    // 文字列をバイトの配列に変換
    let bytes = s.as_bytes();

    // バイトの配列に対してイテレーターを作成
    // enumerateから返されるタプルの最初の要素はインデックスで、2番目の要素は要素への参照
    for (i, &item) in bytes.iter().enumerate() {
        // スペースが見つかったら、位置を返す
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

let s = String::from("hello world");

let hello = &s[0..5];
let world = &s[6..11];

fn first_word(s: &str) -> &str {

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

    // first_word works on slices of `String`s
    let word = first_word(&my_string[..]);

    let my_string_literal = "hello world";

    // first_word works on slices of string literals
    let word = first_word(&my_string_literal[..]);

    // Because string literals *are* string slices already,
    // this works too, without the slice syntax!
    let word = first_word(my_string_literal);
}

let a = [1, 2, 3, 4, 5];

let slice = &a[1..3];