Rustのスライス型とは？初心者向けに基本から注意点まで解説

特に大きなデータ（例えば、巨大なテキストファイルの内容とか、大量の数値データとか）の一部だけを使いたい時、いちいち全部コピーしていたらメモリも時間ももったいないですよね。スライスを使えば、必要な部分だけを参照できるので、とってもエコなんです。

柔軟性が高い！

例えば、関数を作る時を考えてみてください。ある関数が文字列を受け取るとします。

もしその関数が `String` 型（Rustの文字列型の一つ）しか受け付けなかったら、文字列リテラル（プログラム内に直接書かれた文字 `"hello"` など）を渡す時や、`String` の一部分だけを渡したい時に、ひと手間必要になることがあります。

でも、関数が文字列スライス `&str` を受け取るように作られていれば、`String` からも、文字列リテラルからも、`String` の一部分からも、同じようにデータを渡せるようになります。

これは配列やベクタ（可変長の配列のようなもの）とそのスライス `&[T]` でも同じことが言えます。いろんな種類のデータ元から、同じように一部分を扱えるのは、とても便利ですよね。

安全性が高い！

Rustには「借用チェッカー」という、プログラムの安全を守るための見張り番のような仕組みがあります。

スライスはデータを「借用」する仕組みなので、この借用チェッカーの監視下にあります。これにより、「もう使われなくなったはずのデータを参照してしまう」といった危険なバグを、プログラムを実行する前に見つけ出してくれるんです。安心してコードを書けるのは、大きなメリットと言えるでしょう。

このように、スライス型はメモリ効率、柔軟性、安全性の面でRustプログラミングに欠かせない要素となっているわけです。

Rustのスライス型の基本的な書き方

では、実際にスライスをどうやって作るのか、基本的な書き方を見ていきましょう。スライスの作成には、主に範囲を指定する方法を使います。

配列やベクタ、文字列など、連続したデータのかたまりに対して、[開始位置..終了位置] のように書くことで、その部分を指すスライスを作れます。

例えば、こんな配列があったとします。

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

この配列の、2番目から4番目まで（インデックスで言うと1から3まで。Rustのインデックスは0から始まります）を指すスライスを作りたい場合は、こう書きます。

let slice = &a[1..4]; // [2, 3, 4] を指すスライス

ここでポイントなのが、先頭についている & です。これは「参照（借用）ですよ」という印。そして [1..4] の部分が範囲指定です。

1 が開始インデックス、4 が終了インデックスですが、終了インデックスの要素は含まれない点に注意してくださいね（つまり、インデックス1, 2, 3の要素が範囲になります）。

範囲指定にはいくつかバリエーションがあります。

• &a[1..] インデックス1から最後まで
• &a[..3] 最初からインデックス3の手前まで（インデックス0, 1, 2）
• &a[..] 最初から最後まで全部

文字列 (`String`) から文字列スライス (`&str`) を作る場合も同じような感じです。

let s = String::from("hello world");
let hello = &s[0..5]; // "hello" を指す文字列スライス (&str型)
let world = &s[6..11]; // "world" を指す文字列スライス (&str型)

型の表記としては、一般的なデータのスライスは &[T] （Tはデータの型、例えば数値なら `&[i32]`）、文字列スライスは特別に &str と書く、と覚えておきましょう。

Rustのスライス型の使い方

基本が分かったところで、次は実際のコードでスライス型がどう活躍するのか見ていきましょう！ 文字列スライスと、配列やベクタのスライス、それぞれ例を挙げてみますね。

文字列スライス (`&str`) の使い方

文字列スライス (`&str`) は、Rustで文字列を扱う上で本当によく出てきます。

String 型（ヒープ領域に確保される、変更可能な文字列）の一部や、プログラム内に直接書かれた文字列リテラル（これは元々 `&'static str` という特別なスライス型です）を扱うのに便利です。

例えば、String の最初の単語だけを取り出す関数を考えてみましょう。

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i]; // 最初に見つかったスペースまでのスライスを返す
        }
    }

    &s[..] // スペースが見つからなければ、文字列全体のスライスを返す
}

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

    // Stringを渡して最初の単語(&str)を得る
    let word = first_word(&my_string); 

    println!("最初の単語は: {}", word); // 出力: 最初の単語は: hello

    // my_stringの内容が変わっても、wordは最初のスライスを保持しようとするが...
    // my_string.clear(); // ここでエラー！ 不変な参照(word)があるのに、可変な操作(clear)はできない

    // println!("最初の単語は: {}", word); // clear()が実行されると、ここには到達できない
}

このコードでは、first_word 関数は String への参照 (&String) を受け取り、スペースを見つけてそこまでの文字列スライス (&str) を返しています。

ポイントは、関数が返すのは文字列のコピーではなく、元の `String` の一部分を指すスライスだという点です。だからメモリ効率が良いんですね。

（コメントアウトしてある my_string.clear(); の部分に注目してください。

スライス `word` が元の `String` を不変で借りている間は、元の `String` を変更（ここでは `clear()` で空にする）しようとすると、Rustのコンパイラが「危ないよ！」とエラーを出してくれます。これがRustの安全性です。）

ちなみに、関数が &String ではなく &str を受け取るように書くと、もっと柔軟になります。なぜなら、String からも &str を作って渡せるし、文字列リテラル（これも &str）も直接渡せるからです。

fn first_word_flexible(s: &str) -> &str { // 引数を &str に変更
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

fn main() {
    let my_string = String::from("hello rust world");
    let my_string_literal = "goodbye space";

    let word1 = first_word_flexible(&my_string[..]); // String全体のスライスを渡す
    let word2 = first_word_flexible(&my_string[6..10]); // Stringの一部のスライス("rust")を渡す
    let word3 = first_word_flexible(my_string_literal); // 文字列リテラル(&str)を直接渡す

    println!("word1: {}", word1); // 出力: word1: hello
    println!("word2: {}", word2); // 出力: word2: rust
    println!("word3: {}", word3); // 出力: word3: goodbye
}

このように、関数が &str を受け取ることで、より多くの場面で使いやすくなりますね！

配列・ベクタのスライス (`&[T]`) の使い方

文字列だけでなく、数値の配列 ([i32; 5] など) やベクタ (Vec<f64> など) でもスライスは大活躍します。考え方は文字列スライスと同じです。

例えば、数値スライスの合計値を計算する関数を作ってみましょう。

// &[i32] 型のスライスを受け取り、合計値を返す関数
fn sum_slice(numbers: &[i32]) -> i32 {
    let mut total = 0;
    for number in numbers { // スライス内の各要素を順番に処理
        total += number;
    }
    total // 合計値を返す
}

fn main() {
    let my_array = [10, 20, 30, 40, 50];
    let my_vector = vec![1, 2, 3, 4, 5, 6];

    // 配列全体のスライスを渡す
    let sum1 = sum_slice(&my_array[..]); 
    println!("配列全体の合計: {}", sum1); // 出力: 配列全体の合計: 150

    // 配列の一部のスライスを渡す
    let sum2 = sum_slice(&my_array[1..3]); // インデックス1, 2 の要素 (20, 30) のスライス
    println!("配列の一部の合計: {}", sum2); // 出力: 配列の一部の合計: 50

    // ベクタ全体のスライスを渡す
    let sum3 = sum_slice(&my_vector[..]);
    println!("ベクタ全体の合計: {}", sum3); // 出力: ベクタ全体の合計: 21

    // ベクタの一部のスライスを渡す
    let sum4 = sum_slice(&my_vector[3..]); // インデックス3から最後まで (4, 5, 6) のスライス
    println!("ベクタの一部の合計: {}", sum4); // 出力: ベクタの一部の合計: 15
}

この sum_slice 関数は、引数として &[i32] （i32型の数値のスライス）を受け取ります。

この関数は、元のデータが固定長の配列だろうが、可変長のベクタだろうが、気にせず処理できるのが強みです。関数に渡す側は、&配列名[範囲] や &ベクタ名[範囲] のようにしてスライスを作って渡すだけです。

もしこの関数が Vec しか受け付けなかったら、配列を渡すためにわざわざベクタに変換する必要が出てきてしまい、ちょっと面倒ですよね。スライスを使うことで、より汎用的な関数が作れるわけです。

スライスを使った関数定義

ここまでの例で見てきたように、自分で関数を作る際には、多くの場合、String や Vec のような所有権を持つ型を直接受け取るよりも、スライス型 (&str や &[T]) を受け取る方が良い選択になります。

理由はもうお分かりかもしれませんが、まとめると…

• 柔軟性
  いろんなデータソース（String、文字列リテラル、配列、ベクタなど）から、同じ関数を利用できるようになります。
• 効率性
  関数の呼び出し時に不要なデータのコピーや所有権の移動が発生しにくくなります。

例えば、文字列を表示するだけのシンプルな関数を考えてみましょう。

// 非推奨: Stringを受け取る関数 (呼び出し側で所有権を渡すか、クローンする必要がある)
fn print_string_owned(s: String) {
    println!("{}", s);
}

// 推奨: &strを受け取る関数 (様々な文字列ソースから参照を渡せる)
fn print_string_borrowed(s: &str) {
    println!("{}", s);
}

fn main() {
    let owned_string = String::from("これはStringです");
    let string_literal = "これは文字列リテラルです";

    // print_string_owned に渡すと所有権が移動してしまう
    // print_string_owned(owned_string); 
    // println!("{}", owned_string); // この行はエラーになる（所有権がないため）

    // クローンして渡せば元のデータは残るが、コピーが発生する
    print_string_owned(owned_string.clone());
    println!("元のStringはまだ使える: {}", owned_string);

    println!("---");

    // print_string_borrowed なら参照を渡すだけ
    print_string_borrowed(&owned_string); // Stringのスライスを渡す
    print_string_borrowed(string_literal); // 文字列リテラル(&str)をそのまま渡す
    print_string_borrowed(&owned_string[3..9]); // Stringの一部のスライスを渡す

    println!("参照渡しなので元のStringはまだ使える: {}", owned_string);
}

関数を設計する時は、「データ全体が必要で、関数内で所有権を持ちたい」という特別な理由がない限り、スライス (`&str` や `&[T]`) を引数に取ることを基本にすると、多くの場合でうまくいくでしょう。

Rustのスライス型を使う上での注意点

さて、便利なスライス型ですが、使う上でいくつか気をつけておきたい点もあります。特にRustの「所有権」や「借用」のルールと密接に関わっているので、そのあたりを意識すると、よりスムーズに使えるようになりますよ。

スライスと所有権・借用の関係

これまでも何度か触れてきましたが、スライスはデータの「借用」である、という点がとても根本的な性質です。

Rustの借用ルールを思い出してみましょう。

• あるデータに対して、不変の参照 (&T) は同時に複数持つことができる。
• あるデータに対して、可変の参照 (&mut T) は同時に一つしか持つことができない。
• 可変の参照を持っている間は、不変の参照を持つことはできない。（逆もしかり）

スライスもこのルールの影響を受けます。

• 不変のスライス (&[T] や &str) は、同じデータに対して複数作ることができます。
• 可変のスライス (&mut [T]) は、同じデータに対して一つしか作れません。
• 可変のスライスを持っている間は、そのデータの不変のスライスを作ることはできませんし、逆もできません。

fn main() {
    let mut numbers = vec![1, 2, 3, 4];

    let slice1 = &numbers[..]; // 不変のスライス1
    let slice2 = &numbers[1..3]; // 不変のスライス2 (これはOK)

    println!("slice1: {:?}, slice2: {:?}", slice1, slice2);

    // let mutable_slice = &mut numbers[..]; // エラー！不変の参照(slice1, slice2)が存在する

    // もし可変のスライスを先に作ると...
    let mut numbers2 = vec![5, 6, 7, 8];
    let mutable_slice = &mut numbers2[..]; // 可変のスライス
    mutable_slice[0] = 50; // 可変スライスを通してデータを変更できる

    // let slice3 = &numbers2[..]; // エラー！可変の参照(mutable_slice)が存在する

    println!("mutable_slice: {:?}", mutable_slice);
}

この借用ルールのおかげで、「ある場所でデータを変更している最中に、別の場所が古いデータ（変更前）を参照してしまう」といったややこしいバグを防いでくれるのです。

最初は少し窮屈に感じるかもしれませんが、慣れるとプログラムの安全性を高めてくれる心強い味方になりますよ。

スライスの範囲外アクセスについて

スライスを作るとき、[開始位置..終了位置] のように範囲を指定しますが、もしこの範囲が元のデータの範囲を超えていたらどうなるのでしょうか？

例えば、要素が3つしかない配列なのに、[0..5] のような範囲を指定しようとした場合です。

fn main() {
    let data = [10, 20, 30];

    // let invalid_slice = &data[0..5]; // これは実行時エラー（パニック）を引き起こす！
    
    // 安全なアクセス方法として .get() がある
    let valid_slice = data.get(0..2); // インデックス0, 1 を取得 (Some(&[10, 20]))
    let out_of_bounds_slice = data.get(0..5); // 範囲外なので None を返す
    let single_element = data.get(1); // インデックス1の要素を取得 (Some(&20))
    let non_existent_element = data.get(10); // 存在しないインデックスなので None を返す

    println!("Valid slice: {:?}", valid_slice);
    println!("Out of bounds slice: {:?}", out_of_bounds_slice);
    println!("Single element: {:?}", single_element);
    println!("Non-existent element: {:?}", non_existent_element);

    // .get() の結果は Option 型なので、match などで安全に扱える
    match data.get(1..3) {
        Some(slice) => println!("Got slice: {:?}", slice), // 出力: Got slice: [20, 30]
        None => println!("Slice index out of bounds"),
    }
}

範囲指定 [start..end] を使ったアクセスは、もし範囲外を指してしまうと、プログラムの実行中に「パニック（panic）」と呼ばれるエラーが発生してプログラムが停止します。これは、不正なメモリアクセスを防ぐためのRustの安全機能の一つです。

もし「範囲外かもしれないけど、エラーで止まるのは困るな…」という場合は、コード例にあるように .get() メソッドを使うのが良いでしょう。

.get() は、範囲が有効なら Some(スライス) を、範囲外なら None を返します。この Option 型を使うことで、パニックせずに範囲外アクセスを安全に処理できますね。

【まとめ】Rustのスライス型をマスターして効率的なコードを書こう

さて、今回はRustのスライス型について、基本から使い方、注意点まで駆け足で見てきました。

もう一度ポイントをおさらいしておきましょう。

• スライス型は、データ全体ではなく一部分を指し示す「参照」であること。
• 所有権を持たず、データを「借用」する仕組みであること。
• 主なメリットは、メモリ効率の良さ、柔軟性の高さ、安全性の高さであること。
• 基本的な作り方は、&配列名[開始..終了] や &文字列変数[開始..終了] のように範囲を指定すること。
• 文字列スライスは &str、一般的なデータスライスは &[T] と表記されること。
• 関数定義では、多くの場合、所有権を持つ型よりスライス型を引数に取る方が柔軟で効率的であること。
• 借用ルールに従う必要があり、範囲外アクセスには注意が必要であること（.get() が便利）。

スライス型を理解して使いこなすことは、効率的で安全な、そして「Rustらしい」コードを書くための大きな一歩になります。

最初は少し戸惑う部分もあるかもしれませんが、実際にコードを書きながら試していくうちに、きっとその便利さを実感できるはずです。

ぜひ、今日から皆さんのRustコードにスライス型を取り入れてみてくださいね！応援しています！

【関連記事】
Rustとは？いま学ぶべき理由と特徴や始め方を詳しく解説