実行できるGoドキュメント: ポインタ

Q: Goの&と*は何を意味しますか？

&x は x のアドレスを取り、T 型のポインタを返します。p はポインタを参照外しし、指している値を読み書きします。型の中の *T は「Tへのポインタ」という意味です。

Q: Goのnewとmakeの違いは何ですか？

new(T) はゼロ値の T を確保して *T を返し、どんな型にも使えます。make はスライス、マップ、チャネルにだけ使え、その型の初期化済みの（ゼロ値でもポインタでもない）値を返します。make(map[string]int) はすぐに使えますが、new(map[string]int) はnilマップへのポインタです。

Q: Goでローカル変数へのポインタを返せますか？

返せます。Cと違って安全です。コンパイラのエスケープ解析が、変数が関数より長く生きることを見抜き、ヒープに確保します。func newInt() *int { x := 5; return &x } は正しいGoのコードです。

Q: Goの「invalid memory address or nil pointer dereference」の原因は何ですか？

nilポインタを通した読み書きです。一度も代入されていない T の変数、map[K]V で存在しないキーを参照したとき、チェックしなかったエラーと一緒に nil を返した関数などが原因になります。nilをチェックするか、使う前にポインタを初期化します。

Q: Goにポインタ演算はありますか？

ありません。ポインタに数を足したり、ポインタを通してメモリにインデックスでアクセスしたりはできません。低レベルのコード向けに unsafe パッケージでは可能ですが、安全性の保証はありません。普通のGoのコードでは、連続したメモリにはスライスを使います。

&と*

ポインタは値のメモリアドレスを保持します。&x は x へのポインタを返します。*p はポインタをたどって値にたどり着きます。

package main

import "fmt"

func main() {
	x := 10
	p := &x // p has type *int

	fmt.Println(*p) // read through the pointer: 10
	*p = 20         // write through the pointer
	fmt.Println(x)  // x changed: 20

	fmt.Printf("%T\n", p)
	fmt.Println(p != nil)
}

アスタリスクには2つの役割があります。型の中（*int）では「intへのポインタ」を意味します。式の中（*p）では「pが指す値」を意味します。p そのものを表示すると 0xc000012345 のようなアドレスが表示され、実行するたびに変わります。

ポインタがある理由：コピーではなく共有

Goはすべてを値で渡します。関数は各引数のコピーを受け取るので、呼び出し側の変数を変更できません。ポインタを渡すと代わりにアドレスがコピーされ、両方が同じ値にたどり着きます。

package main

import "fmt"

func doubleCopy(n int) {
	n *= 2
}

func doublePtr(n *int) {
	*n *= 2
}

func main() {
	v := 21
	doubleCopy(v)
	fmt.Println(v) // 21

	doublePtr(&v)
	fmt.Println(v) // 42
}

GoにC++の意味での参照はありません。Goでの「参照渡し」とは、ポインタを値で渡すことです。

構造体へのポインタ

Goのコードで最もよく使われるポインタは構造体へのポインタです。フィールドへのアクセスは自動で参照外しされます。p.Name は (*p).Name という意味です。

package main

import "fmt"

type Account struct {
	Owner   string
	Balance int
}

func (a *Account) Deposit(n int) {
	a.Balance += n // no explicit * needed
}

func main() {
	acc := &Account{Owner: "Ana"} // pointer to a new struct
	acc.Deposit(100)
	acc.Balance -= 30
	fmt.Println(acc.Owner, acc.Balance)

	same := acc
	same.Balance = 0
	fmt.Println(acc.Balance) // 0: both variables point at one Account
}

メソッドも同じ理屈に従います。ポインタレシーバーを使うと、メソッドが構造体を変更できます。値レシーバーとポインタレシーバーの選び方はメソッドのページで扱っています。

new

new(T) はゼロ値の T を確保し、そのアドレスを返します。変数を宣言してそのアドレスを取るのと同じです。

p := new(int) // *int pointing at 0
var x int
q := &x           // same thing, two lines
a := new(Account) // same as &Account{}

実際には、構造体には &T{...} のほうがよく使われます。同じ式でフィールドを設定できるからです。new は基本型へのポインタに便利です。スライス、マップ、チャネルを作ってポインタではなくすぐ使える状態で返す make と混同しないでください。

ローカル変数へのポインタを返すのは安全

Cでは、ローカル変数のアドレスを返すのはバグです。Goではごく普通のコードです。

package main

import "fmt"

type Config struct {
	Port int
	Mode string
}

func defaultConfig() *Config {
	c := Config{Port: 8080, Mode: "dev"}
	return &c // c outlives the call, so it lives on the heap
}

func main() {
	cfg := defaultConfig()
	cfg.Mode = "prod"
	fmt.Printf("%+v\n", *cfg)
}

値がスタックとヒープのどちらに置かれるかは、コンパイラのエスケープ解析が決めます。自分で選ぶことはなく、メモリを解放することもありません。何も指さなくなったら、ガベージコレクタが回収します。気になるなら go build -gcflags=-m でその判断を表示できます。

nilポインタ

どのポインタ型もゼロ値は nil です。nilを参照外しするとpanicします。

package main

import "fmt"

type Node struct {
	Val  int
	Next *Node
}

func main() {
	defer func() {
		fmt.Println("recovered:", recover())
	}()

	list := &Node{Val: 1, Next: &Node{Val: 2}}
	for n := list; n != nil; n = n.Next {
		fmt.Println(n.Val)
	}

	var missing *Node
	fmt.Println(missing == nil)
	fmt.Println(missing.Val) // panics
}

出力：

1
2
true
recovered: runtime error: invalid memory address or nil pointer dereference

recover がなければ、プログラムはこのメッセージと、panic: runtime error: invalid memory address or nil pointer dereference と [signal SIGSEGV: segmentation violation ...] で始まるスタックトレースとともにクラッシュします。よくある原因は次のとおりです。

一度も設定されていないポインタ変数や構造体のフィールド
map[string]*T での存在しないキーの m[key]（nil を返す）
エラーの無視：f, _ := os.Open(path) は失敗時に f をnilのままにする
nilポインタに対して呼ばれ、フィールドを読むポインタレシーバーのメソッド

nilポインタでメソッドを呼ぶこと自体は正しいコードです。panicが起きるのは、メソッドがレシーバーのフィールドに触れたときだけです。

ポインタを使うべきとき

ポインタを使うのは次のようなときです。

関数やメソッドが呼び出し側の値を変更する必要がある
値が大きな構造体で、頻繁に受け渡される
型をコピーしてはいけない（sync.Mutex を含む、または接続のような一意のリソースを表す）
nil で「値がない」ことを表したい。たとえばJSONの構造体の省略可能なフィールドでは、*int が「ない」と 0 を区別する

ポインタを使わないのは次のようなときです。

値が小さく読み取り専用（time.Time、Point）
型がすでに参照のような値である。スライス、マップ、チャネル、関数、インターフェースの前に * が必要になることはまれで、*[]int や *map[string]int はほぼ常に間違いです

ポインタが自動的に速くなるわけではありません。小さな構造体のコピーは安価で、ポインタはヒープへの確保を強いてガベージコレクタの仕事を増やすことがあります。

ポインタとループ変数

Go 1.22以降、反復ごとに独自の変数があるので、ループ変数のアドレスを取るのは安全です。

package main

import "fmt"

func main() {
	var ptrs []*int
	for i := range 3 {
		ptrs = append(ptrs, &i)
	}
	for _, p := range ptrs {
		fmt.Print(*p, " ")
	}
	fmt.Println()
}

これは 0 1 2 と表示します。Go 1.22（range 3 もこのバージョンで入りました）より前は、同じループを for i := 0; i < 3; i++ で書くと、3つのポインタが1つの変数を共有していたので 3 3 3 と表示されました。for _, v := range items での &v は、スライスの中の要素ではなく要素のコピーを指すことに注意してください。要素そのものへのポインタを得るには &items[i] を使います。

よくある間違い

チェックせずに参照外しする。 nilになりうる場所では if p == nil をチェックします。
rangeの値へのポインタ。 &v はコピーを指します。&s[i] を使います。
スライスやマップへのポインタ。 必要になることはまれです。代わりに新しいスライスを返します。
append をまたいで &s[i] を保持する。 append が再確保すると、ポインタは古い配列を指したままで、その後の書き込みはどこにも見えない場所に入ります。

よくある質問

Goの&と*は何を意味しますか？

&x は x のアドレスを取り、*T 型のポインタを返します。*p はポインタを参照外しし、指している値を読み書きします。型の中の *T は「Tへのポインタ」という意味です。

Goのnewとmakeの違いは何ですか？

new(T) はゼロ値の T を確保して *T を返し、どんな型にも使えます。make はスライス、マップ、チャネルにだけ使え、その型の初期化済みの（ゼロ値でもポインタでもない）値を返します。make(map[string]int) はすぐに使えますが、new(map[string]int) はnilマップへのポインタです。

Goでローカル変数へのポインタを返せますか？

返せます。Cと違って安全です。コンパイラのエスケープ解析が、変数が関数より長く生きることを見抜き、ヒープに確保します。func newInt() *int { x := 5; return &x } は正しいGoのコードです。

Goの「invalid memory address or nil pointer dereference」の原因は何ですか？

nilポインタを通した読み書きです。一度も代入されていない *T の変数、map[K]*V で存在しないキーを参照したとき、チェックしなかったエラーと一緒に nil を返した関数などが原因になります。nilをチェックするか、使う前にポインタを初期化します。

Goにポインタ演算はありますか？

ありません。ポインタに数を足したり、ポインタを通してメモリにインデックスでアクセスしたりはできません。低レベルのコード向けに unsafe パッケージでは可能ですが、安全性の保証はありません。普通のGoのコードでは、連続したメモリにはスライスを使います。