Go言語の構造体とポインタについて解説

2025-04-15更新日: 2025-04-15

Go言語では構造体とポインタを組み合わせることで、データ管理や操作が効率的に行えます。

この記事では、シンプルな例を交えながら基本的な使い方と活用方法を解説します。

すでに開発環境が整っている方は、すぐに試していただける内容です。

目次から探す

構造体の定義と基本
- 構造体の宣言方法
- 構造体の初期化
ポインタの基本操作と役割
- ポインタの宣言と利用方法
- ポインタを用いた値の変更
構造体とポインタの組み合わせ
- ポインタを活用した構造体操作
- メソッドにおけるポインタ利用
実践例による検証
- 基本的なコード例
- 注意点と対策
まとめ

Go言語を使った求人

読み込み中…

構造体の定義と基本

構造体の宣言方法

定義文法の基本

Go言語では、構造体は独自の型として定義され、複数のフィールドをまとめるためによく用いられます。

構造体の定義は以下のような文法で記述します。

package main
import "fmt"
// 構造体Personの定義
type Person struct {
	Name string  // 名前
	Age  int     // 年齢
}
func main() {
	// 空の構造体を宣言
	var p Person
	fmt.Println("名前:", p.Name, "年齢:", p.Age)
}

名前:  年齢: 0

メンバの設定方法

構造体の各メンバには、ドット演算子を用いてアクセスし、値を設定することができます。

たとえば、先ほど定義したPerson構造体では、以下のように各メンバに値を設定できます。

package main
import "fmt"
type Person struct {
	Name string
	Age  int
}
func main() {
	// 構造体変数pの各フィールドに値を代入
	var p Person
	p.Name = "太郎"  // 名前を設定
	p.Age = 25      // 年齢を設定
	fmt.Println("名前:", p.Name, "年齢:", p.Age)
}

名前: 太郎 年齢: 25

構造体の初期化

リテラルを用いた初期化

構造体はリテラル形式で一度に初期化することができます。

フィールド名を指定する場合と、指定しない場合の2通りの方法があります。

package main
import "fmt"
type Person struct {
	Name string
	Age  int
}
func main() {
	// フィールド名を指定して初期化
	p1 := Person{
		Name: "花子",
		Age:  30,
	}
	fmt.Println("名前:", p1.Name, "年齢:", p1.Age)
	// フィールド名を省略して初期化(順番に依存)
	p2 := Person{"次郎", 22}
	fmt.Println("名前:", p2.Name, "年齢:", p2.Age)
}

名前: 花子 年齢: 30
名前: 次郎 年齢: 22

new関数による初期化

new関数を用いると、構造体のポインタを取得することができます。

この方法では、フィールドはゼロ値で初期化されるため、後から必要に応じて値を設定する形になります。

package main
import "fmt"
type Person struct {
	Name string
	Age  int
}
func main() {
	// new関数を利用して構造体のポインタを作成
	p := new(Person)
	// ポインタ経由でフィールドにアクセス
	p.Name = "健一"
	p.Age = 28
	fmt.Println("名前:", p.Name, "年齢:", p.Age)
}

名前: 健一 年齢: 28

ポインタの基本操作と役割

ポインタの宣言と利用方法

宣言と参照の基本

ポインタは変数のアドレスを保持するための型です。

変数のアドレスを取得するにはアンパサンド&演算子を使い、ポインタ変数の宣言は以下のように行います。

package main
import "fmt"
func main() {
	// 変数の宣言
	number := 100
	// 変数numberのアドレスを取得してポインタ変数ptrに代入
	ptr := &number
	fmt.Println("numberの値:", number)
	fmt.Println("ptrが指すアドレス:", ptr)
}

numberの値: 100
ptrが指すアドレス: 0xc000016088

解参照演算子の使い方

解参照演算子*を用いると、ポインタが指す先の値にアクセスできます。

以下の例では、ポインタを使って変数の値に直接アクセスし、変更も行っています。

package main
import "fmt"
func main() {
	number := 50
	ptr := &number  // ポインタ変数ptrにnumberのアドレスを代入
	// ptrを解参照してnumberの値を変更
	*ptr = 75
	fmt.Println("変更後のnumber:", number)
}

変更後のnumber: 75

ポインタを用いた値の変更

値の変更の流れ

ポインタを通じて変数の値を変更する場合、まず変数のアドレスを取得し、そのポインタ経由で値を操作します。

この方法は、大きなデータ構造を関数間で渡す場合などに、効率的なメモリ利用が可能となります。

package main
import "fmt"
// incrementはポインタを通じて引数の値を増加させる関数
func increment(num *int) {
	*num = *num + 1  // 解参照して値を更新
}
func main() {
	value := 10
	fmt.Println("変更前:", value)
	increment(&value)
	fmt.Println("変更後:", value)
}

変更前: 10
変更後: 11

構造体とポインタの組み合わせ

ポインタを活用した構造体操作

メモリ効率の向上

大きな構造体やデータ構造を関数に渡す場合、値渡しするとコピーが発生しメモリ効率が低下する可能性があります。

構造体のポインタを渡すことで、コピーを避け、メモリ効率を向上させることができます。

package main
import "fmt"
type Data struct {
	Value1 int
	Value2 int
	Value3 int
}
func process(d *Data) {
	// ポインタを受け取ることで、実体のコピーが発生しない
	d.Value1 = d.Value1 * 2
}
func main() {
	d := Data{10, 20, 30}
	fmt.Println("変更前:", d)
	process(&d)  // ポインタを渡す
	fmt.Println("変更後:", d)
}

変更前: {10 20 30}
変更後: {20 20 30}

値の共有と変更

構造体のポインタを利用すると、複数の関数やメソッドで同一のインスタンスを参照し、値を共有・変更することが容易になります。

この方法は、データ更新の一貫性を保つ上で有効です。

package main
import "fmt"
type Config struct {
	Mode string
}
func updateConfig(c *Config, newMode string) {
	c.Mode = newMode  // 直接値を変更
}
func main() {
	config := Config{"開発"}
	fmt.Println("更新前:", config.Mode)
	updateConfig(&config, "本番")
	fmt.Println("更新後:", config.Mode)
}

更新前: 開発
更新後: 本番

メソッドにおけるポインタ利用

ポインタレシーバの特徴

構造体のメソッドでポインタレシーバを利用すると、レシーバの値を直接変更することができます。

値レシーバの場合、メソッド内で行った変更は呼び出し元に反映されませんが、ポインタレシーバならそのまま更新が可能です。

package main
import "fmt"
type Counter struct {
	Count int
}
// ポインタレシーバを利用してカウンタを増加
func (c *Counter) Increment() {
	c.Count++
}
func main() {
	c := Counter{0}
	fmt.Println("初期値:", c.Count)
	c.Increment()
	fmt.Println("更新後:", c.Count)
}

初期値: 0
更新後: 1

実践例による検証

基本的なコード例

構造体ポインタの活用例

以下のサンプルコードでは、構造体Bookを定義し、そのポインタを使って値を設定・変更しています。

コード内にわかりやすいコメントを記述しているので、処理の流れが理解しやすい構造となっています。

package main
import "fmt"
type Book struct {
	Title  string
	Author string
}
func main() {
	// Book型のインスタンスをnew関数で作成し、ポインタを得る
	bookPtr := new(Book)
	// ポインタを通じてフィールドに値を設定
	bookPtr.Title = "Go入門"
	bookPtr.Author = "山田太郎"
	fmt.Println("書籍タイトル:", bookPtr.Title)
	fmt.Println("著者名:", bookPtr.Author)
}

書籍タイトル: Go入門
著者名: 山田太郎

メソッドでの動作確認

次のコードは、構造体Calculatorに対してポインタレシーバを利用したメソッドを実装した例です。

メソッド内で状態が更新され、呼び出し元にその変更が反映される様子を確認できます。

package main
import "fmt"
type Calculator struct {
	Result int
}
// ポインタレシーバを利用して計算結果を更新
func (c *Calculator) Add(value int) {
	c.Result += value
}
func main() {
	calc := Calculator{0}
	fmt.Println("初期結果:", calc.Result)
	calc.Add(15)
	fmt.Println("加算後の結果:", calc.Result)
}