Go言語のスライス：lenとcapの仕組みと正しい使い分け

2026年5月25日

コレクション

Go言語において、スライスは最も頻繁に使用されるデータ構造の一つですが、その内部的な仕組みを正しく理解することは効率的なプログラミングを行う上で欠かせません。

特に、スライスの「長さ (len)」と「容量 (cap)」の違いは、初心者から中級者へステップアップする際に必ず直面する重要なポイントです。

本記事では、Go言語のスライスが内部でどのようにメモリを管理しているのか、そしてパフォーマンスを最大限に引き出すための正しい使い分けについて詳しく紹介します。

目次 [ close ]

スライスの内部構造：記述子としての役割

Go言語のスライスは、それ自体がデータを保持しているのではなく、背後にある「配列」への参照を持つ構造体のような役割を果たしています。

この構造体は内部的に、背後にある配列へのポインタ、現在のスライスの長さ (len)、および確保されている容量 (cap) の3つのフィールドで構成されています。

スライスを操作するということは、この3つの値を書き換える、あるいは新しい構造体を作成することを意味します。

ポインタは、スライスが参照しているメモリ領域の先頭アドレスを指し示しています。

スライスが「可変長」に見えるのは、この内部構造が動的に管理されているためです。

しかし、実際のメモリ領域である背後の配列は固定長であり、この配列のサイズを超えようとしたときに新しいメモリが再割り当てされる仕組みになっています。

長さ (len) とは何か

スライスが現在保持している要素数

長さ (len) とは、スライスが現在アクセス可能な要素の数を表します。

組み込み関数である len() を使用することで、そのスライスに現在いくつのデータが格納されているかを取得できます。

例えば、s := []int{1, 2, 3} というスライスを作成した場合、長さは 3 となります。

この長さの範囲を超えてインデックス指定によるアクセスを試みると、Goのランタイムはパニック (index out of range) を発生させます。

つまり、長さとは「プログラムから安全に読み書きできる範囲」を定義していると言い換えることができます。

容量 (cap) とは何か

背後にある配列の全サイズ

容量 (cap) とは、スライスの先頭要素から数えて、背後にある配列にどれだけの要素を格納できるかという限界値を表します。

組み込み関数である cap() を使用することで、再割り当てなしで追加可能な最大数を取得できます。

スライスの長さが 3 であっても、容量が 10 あれば、あと 7 要素分はメモリの再確保なしに要素を追加することが可能です。

容量は、スライスのパフォーマンスを最適化する上で極めて重要な指標となります。

容量が不足した状態で要素を追加しようとすると、新しい大きな配列が確保され、既存のデータがすべてコピーされるというコストの高い処理が発生します。

lenとcapの変化を確認する

スライスに要素を追加した際に、lenとcapがどのように変化するかを具体的なコードで確認してみましょう。

package main

import "fmt"

func main() {
    // 長さ0、容量5のスライスを作成
    s := make([]int, 0, 5)
    fmt.Printf("Initial: len=%d, cap=%d\n", len(s), cap(s))

    // 要素を追加
    for i := 1; i <= 3; i++ {
        s = append(s, i)
    }
    fmt.Printf("After 3 appends: len=%d, cap=%d\n", len(s), cap(s))

    // さらに追加して容量を超える準備
    s = append(s, 4, 5, 6)
    fmt.Printf("After exceeding initial cap: len=%d, cap=%d\n", len(s), cap(s))
}

実行結果

Initial: len=0, cap=5
After 3 appends: len=3, cap=5
After exceeding initial cap: len=6, cap=10

この実行結果から分かるように、要素が容量を超えた瞬間に cap が 5 から 10 へと増加しています。

Goのランタイムは、既存の容量が不足すると通常は現在の容量の2倍 (要素数が多い場合は異なる比率) のメモリを新しく確保します。

make関数による効率的な初期化

lenとcapを明示的に指定する重要性

スライスを生成する際、将来的に格納する要素の数が概ね分かっている場合は、make 関数で容量を事前に指定すべきです。

make([]type, len, cap) という構文を使用することで、不要なメモリ再割り当てを防ぐことができます。

例えば、1000個の要素を入れることが分かっているのに make([]int, 0) で初期化してしまうと、append のたびに何度もメモリ確保とコピーが繰り返されます。

初期化時に適切な容量を確保しておくことで、実行速度の大幅な向上が期待できます。

以下の表は、容量指定の有無による違いをまとめたものです。

初期化方法	長さ (len)	容量 (cap)	用途
`make([]int, 5)`	5	5	最初から5つのゼロ値要素を使いたい場合
`make([]int, 0, 5)`	0	5	空の状態から最大5つまで効率よく追加したい場合
`[]int{1, 2, 3}`	3	3	初期値が決まっている場合

スライシングによるlenとcapの変化

既存のスライスから新しいスライスを作成する「スライシング」操作でも、lenとcapの挙動には注意が必要です。

package main

import "fmt"

func main() {
    original := []int{0, 1, 2, 3, 4, 5}
    // インデックス1から4の前までを切り出し
    sub := original[1:4]

    fmt.Printf("original: len=%d, cap=%d\n", len(original), cap(original))
    fmt.Printf("sub: len=%d, cap=%d\n", len(sub), cap(sub))
}

実行結果

original: len=6, cap=6
sub: len=3, cap=5

sub の長さが 3 (1, 2, 3の要素) になるのは直感的ですが、容量が 5 になる点に注目してください。

これは、スライシングによって作成された新しいスライスが、元のスライスと同じ背後の配列を共有しているためです。

容量は「新しいスライスの開始位置から、元の配列の末尾まで」として計算されます。

この挙動を理解していないと、意図しないメモリの共有によるバグを引き起こす可能性があります。

メモリリークを防ぐための「3インデックススライス」

スライシングによって背後の配列が共有される性質は、時にメモリリークの原因となります。

巨大な配列の一部だけをスライスとして保持していても、そのスライスが生きている限り、背後にある巨大な配列全体がメモリ上に残り続けてしまうからです。

これを防ぐために、Go 1.2 以降では「3インデックススライス (Full slice expression)」が導入されました。

s[low:high:max] という形式で、新しいスライスの容量を明示的に制限することができます。

package main

import "fmt"

func main() {
    original := make([]int, 0, 100)
    for i := 0; i < 100; i++ {
        original = append(original, i)
    }

    // 長さ2、容量2のスライスとして切り出し
    safeSub := original[10:12:12]

    fmt.Printf("safeSub: len=%d, cap=%d\n", len(safeSub), cap(safeSub))
    
    // appendしても元の巨大な配列には影響を与えない
    safeSub = append(safeSub, 999)
    fmt.Printf("After append: len=%d, cap=%d\n", len(safeSub), cap(safeSub))
}

実行結果

safeSub: len=2, cap=2
After append: len=3, cap=4

3インデックススライスを使用することで、子スライスが元の配列の容量を勝手に使い切ることを防ぎ、安全にカプセル化することができます。

パフォーマンスに関するベストプラクティス

Goプログラミングにおいて、スライスの操作は最も実行時間に影響を与える部分の一つです。

大量のデータを処理するループ内での append は、極力避けるか、事前に十分な容量を確保してください。

また、非常に大きなスライスからごく一部のデータだけを取り出して長期間保持する場合は、copy 関数を使って新しい小さなスライスにデータを複製することを検討してください。

これにより、参照されなくなった巨大な背後配列がガベージコレクション (GC) の対象になり、メモリ効率が向上します。

スライスの再利用も有効なテクニックです。

同じ型のスライスを何度も作り直すのではなく、s = s[:0] のように長さをリセットすることで、確保済みの容量を再利用し、アロケーション回数を減らすことができます。

まとめ

Go言語のスライスにおける len と cap の仕組みを正しく理解することは、堅牢で高速なアプリケーションを構築するための第一歩です。

長さ (len) は現在の有効な要素数を示し、容量 (cap) はメモリの再確保なしに拡張可能な限界を示しています。

これら二つの性質を意識し、make による事前割り当てや3インデックススライスによる容量制限を活用することで、ランタイムの負荷を大幅に軽減できます。

特に大規模なシステムやリアルタイム性が求められるサービスでは、スライスのメモリ管理がパフォーマンスの決定打となることも少なくありません。

今回解説した内部構造と挙動を念頭に置き、より洗練されたGoコードの執筆に役立ててください。