🦀

Rustの勉強 4日目

2022/09/30に公開約6,600字

The Rust Programming Language 日本語版 第4章

いよいよRustの特徴的な機能である「所有権」について。

4.1 所有権とは

  • ヒープに積まれたデータの整理はすべて所有権が解決する問題である、という主旨のカラムはなんとなくわかった。
  • 文字列リテラルはサイズ固定でイミュータブルだから不便なので、String 型を使う。これはヒープに積まれる。
  • RustはGCや手動での allocate / free の代わりに、スコープを抜けるときに暗黙的に drop という特別な関数を呼んで、不必要になったメモリを返却する。
  • String 型のようにヒープに保持する値がある変数をコピーしようとすると、別のポインターが作られるだけ(shallow copy)でヒープ領域にあるデータは共通となる。
    • この状態のままだと drop したときに過剰にメモリを開放することになるので、Rustではコピー元の方をコンパイラが無効化して呼び出せないようにする。(「ムーブした」と見做す)
{
    let s1 = String::from("hello");
    let s2 = s1; // ここで s1 はムーブされたと見做される
}

もし、shallow copyではなくdeep copyしたかったら、次のように clone メソッドを呼ぶ必要がある。

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

Copy トレイトを持っている特別な型に関しては、データがスタックに積まれているので、shallow copyもdeep copyも違いがなく、ムーブの判定がされなくなる。

  • 関数に値を渡した場合や戻り値でも変数に代入したときと同様のムーブやコピーの判定がされる

4.2 参照と借用

  • 毎回ムーブやコピーを気にしてたら不便なので、 & をつかって参照を渡せる
    • 参照を貰うことを「借用」と呼ぶ。
  • 参照もデフォルトはイミュータブルなので、借用した上で値を変更しようと思ったら &mut でミュータブルな参照にしないといけない。
    • &mut は1つのスコープで1個しか存在してはいけない
    • & で借用されているものは &mut で借用できない
  • ダングリングも防いでくれるので、生成された変数が drop されるタイミングと参照のライフタイムをよく考える必要がある

4.3 スライス型

  • コレクションの中身の要素の一部を参照するための型

Rustlings

primitive_types3.rs

a.len() でコレクションの長さを見ているif式なので、 a を適当にコレクションにした。

fn main() {
    let a = 1..100;

    if a.len() >= 100 {
        println!("Wow, that's a big array!");
    } else {
        println!("Meh, I eat arrays like that for breakfast.");
    }
}

primitive_types4.rs

配列からスライスを取れということだったので、 assert_eq の中身を見て、該当する要素を抜き出すスライスを書いた。

#[test]
fn slice_out_of_array() {
    let a = [1, 2, 3, 4, 5];

    let nice_slice = &a[1..4];

    assert_eq!([2, 3, 4], nice_slice)
}

primitive_types5.rs

下の println! マクロで nameage という変数がプレースホルダに入れられてたので、 cat を展開して受け取った。

fn main() {
    let cat = ("Furry McFurson", 3.5);
    let (name, age) = cat;

    println!("{} is {} years old.", name, age);
}

primitive_types6.rs

タプルの要素はピリオドと添字でアクセスするのでそれを書いた

#[test]
fn indexing_tuple() {
    let numbers = (1, 2, 3);
    // Replace below ??? with the tuple indexing syntax.
    let second = numbers.1;

    assert_eq!(2, second, "This is not the 2nd number in the tuple!")
}

move_semantics1.rs

vec1.push(88) は可変な操作なので、 vec1 を宣言するときにミュータブルで宣言するように変更。

fn main() {
    let vec0 = Vec::new();

    let mut vec1 = fill_vec(vec0);

    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);

    vec1.push(88);

    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
}

fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
    let mut vec = vec;

    vec.push(22);
    vec.push(44);
    vec.push(66);

    vec
}

move_semantics2.rs

vec0fill_vec に渡されたところでムーブされてるので、 vec0.len() として触れない。ムーブではなくコピーとして fill_vec に渡せばコンパイルが通る。

fn main() {
    let vec0 = Vec::new();

    let mut vec1 = fill_vec(vec0.clone());

    // Do not change the following line!
    println!("{} has length {} content `{:?}`", "vec0", vec0.len(), vec0);

    vec1.push(88);

    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
}

fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
    let mut vec = vec;

    vec.push(22);
    vec.push(44);
    vec.push(66);

    vec
}

move_semantics3.rs

fill_vec の仮引数の vec はイミュータブルなので、そのまま実行してしまうと vec.push(22); の行でエラーが出てしまう。なのでシャドーイングをしてミュータブルにした。(これまでの問題のサンプルと同じ方法)

fn main() {
    let vec0 = Vec::new();

    let mut vec1 = fill_vec(vec0);

    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);

    vec1.push(88);

    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
}

fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
    let mut vec = vec;
    vec.push(22);
    vec.push(44);
    vec.push(66);

    vec
}

他の方法として、 fill_vec の仮引数の vec をミュータブルな型として宣言した。

fn main() {
    let mut vec0 = Vec::new();

    let mut vec1 = fill_vec(&mut vec0);

    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);

    vec1.push(88);

    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
}

fn fill_vec(vec: &mut Vec<i32>) -> Vec<i32> {
    vec.push(22);
    vec.push(44);
    vec.push(66);

    vec.to_vec()
}

move_semantics4.rs

fill_vec のコメントに「もう引数を取らない」と書いてあるので、 vec0 が出てくる行は全部消した。そうすると、fill_vec 内で操作している vec の正体が不明なので、新しい Vec 型の値を生成した。戻り値は vec1 にムーブされていて、その後の操作は特に問題がないのでコンパイルが通った。

fn main() {
    let mut vec1 = fill_vec();

    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);

    vec1.push(88);

    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
}

// `fill_vec()` no longer takes `vec: Vec<i32>` as argument
fn fill_vec() -> Vec<i32> {
    let mut vec = Vec::new();

    vec.push(22);
    vec.push(44);
    vec.push(66);

    vec
}

move_semantics5.rs

yz&mut の宣言が立て続けに並んでいるせいで一度に2つ以上の借用が起きているので、 let z = &mut x;*y += 100; を入れ替えて、参照が同時に起きないようにしたらコンパイルが通った。

fn main() {
    let mut x = 100;
    let y = &mut x;
    *y += 100;
    let z = &mut x;
    *z += 1000;
    assert_eq!(x, 1200);
}

しかしなんでこれは次のようにスコープを指定しなくても良いんだろうか。

fn main() {
    let mut x = 100;
    {
        let y = &mut x;
        *y += 100;
    }
    {
        let z = &mut x;
        *z += 1000;
    }
    assert_eq!(x, 1200);
}

(補足: @lambda_sakura さんから、これはライフサイクルの問題も入ってると言われて、まだ読んでない章の知識も必要だったと理解した。)

move_semantics6.rs

まず get_char が必要もなく所有権を取得していたのでイミュータブルな借用をするように変更した。これで string_uppercase でも data が渡せるようになった。
しかし最初の行の data = &data.to_uppercase(); でエラーが出る。

19 | fn string_uppercase(mut data: &String) {
   |                               - let's call the lifetime of this reference `'1`
20 |     data = &data.to_uppercase();
   |     --------^^^^^^^^^^^^^^^^^^^- temporary value is freed at the end of this statement
   |     |       |
   |     |       creates a temporary which is freed while still in use
   |     assignment requires that borrow lasts for `'1`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0716`.

&data.to_uppercase() が一時的な値を生成しして、それを data に渡しているけれども、即消えるから危ないってことらしいんで、とりあえずこの関数の用途であれば data をシャドーイングしとけば良さそう。で、やってみたらコンパイル通った。

fn main() {
    let data = "Rust is great!".to_string();

    get_char(&data);

    string_uppercase(&data);
}

// Should not take ownership
fn get_char(data: &String) -> char {
    data.chars().last().unwrap()
}

// Should take ownership
fn string_uppercase(mut data: &String) {
    let data = &data.to_uppercase();

    println!("{}", data);
}

今日はここまで。

Discussion

ログインするとコメントできます