構造体

Go言語の構造体メソッドについて解説

2025-02-19更新日: 2025-02-19

Go言語で構造体とメソッドを活用すると、データとその操作を一元管理しやすくなります。

構造体には複数のフィールドを持たせ、関連するメソッドを定義することで、直感的なコード設計が実現できます。

シンプルな文法で記述できるため、初心者にも扱いやすく、効率的な開発が可能です。

目次から探す
  1. 構造体の基本
  2. メソッドの基本
  3. 構造体とメソッドの連携活用
  4. 応用例
  5. まとめ

構造体の基本

構造体の定義と宣言

構造体の宣言方法

Goでは複数の型の値をひとまとめに扱うために構造体を使います。

構造体は以下のように宣言します。

Goの宣言方法は以下の通りです。

package main
import "fmt"
// Person は人を表す構造体
type Person struct {
	Name string // 名前
	Age  int    // 年齢
}
func main() {
	// 空の構造体を作成
	var person Person
	person.Name = "Alice"
	person.Age = 30
	fmt.Println("Name:", person.Name, "Age:", person.Age)
}
Name: Alice Age: 30

この例では、Personという構造体を作成し、NameとAgeというフィールドを定義しています。

フィールドの設定と型指定

構造体の各フィールドには名称と型を設定します。

フィールドは組み込み型だけではなく、他の構造体をフィールドとして利用することもできます。

型指定により、フィールドに許容される値が決まるため、データの整合性が保たれます。

例えば、以下の例では住所情報をもつ構造体をフィールドに持つ構造体を定義しています。

package main
import "fmt"
// Address は住所情報を表す構造体
type Address struct {
	City  string // 都市名
	State string // 州または県
}
// Person は人を表す構造体
type Person struct {
	Name    string  // 名前
	Age     int     // 年齢
	Address Address // 住所情報
}
func main() {
	// Addressフィールドも指定して初期化
	var person Person
	person.Name = "Bob"
	person.Age = 28
	person.Address = Address{
		City:  "Tokyo",
		State: "Tokyo-to",
	}
	fmt.Println(person)
}
{Bob 28 {Tokyo Tokyo-to}}

構造体の初期化方法

リテラルによる初期化

構造体はリテラルを使って初期値を設定することが可能です。

リテラルによる初期化では、各フィールドに対応する値を直接指定できます。

以下はリテラルを使った初期化の例です。

package main
import "fmt"
// Product は製品情報を表す構造体
type Product struct {
	ID    int
	Name  string
	Price float64
}
func main() {
	// フィールド名を指定したリテラル初期化
	product := Product{
		ID:    101,
		Name:  "Laptop",
		Price: 999.99,
	}
	fmt.Println("Product:", product)
}
Product: {101 Laptop 999.99}

ゼロ値の利用

構造体を宣言すると、各フィールドには型ごとのゼロ値が自動的に設定されます。

例えば、数値型のゼロ値は0、文字列型は空文字列となります。

以下はゼロ値の利用例です。

package main
import "fmt"
// Item はアイテム情報を表す構造体
type Item struct {
	Code  int
	Title string
	Stock int
}
func main() {
	// ゼロ値で初期化された構造体を作成
	var item Item
	fmt.Println("Item:", item)
}
Item: {0  0}

メソッドの基本

メソッドの定義

レシーバの概念

Goでは、関数に特定の型の変数(レシーバ)を関連付けることで、その型に対するメソッドを定義できます。

レシーバはメソッド定義の先頭に記述し、対象となる値へアクセスできるようになります。

以下はレシーバの概念を示すサンプルです。

package main
import "fmt"
// Person は人を表す構造体
type Person struct {
	Name string
	Age  int
}
// Greet は Person型のメソッド。レシーバとして p を利用する。
func (p Person) Greet() {
	fmt.Printf("Hi, my name is %s.\n", p.Name)
}
func main() {
	person := Person{Name: "Charlie", Age: 25}
	person.Greet() // メソッドの呼び出し
}
Hi, my name is Charlie.

値レシーバの特徴

値レシーバを使ったメソッド定義では、レシーバは値のコピーとなります。

そのため、メソッド内で変更しても元の値への影響はありません。

読み取り専用のメソッドに適しています。

以下は値レシーバを利用する例です。

package main
import "fmt"
// Counter はカウンターを表す構造体
type Counter struct {
	Count int
}
// Increment は値レシーバのため、元のCountは変更されない
func (c Counter) Increment() {
	c.Count++
	fmt.Println("Inside Increment:", c.Count)
}
func main() {
	counter := Counter{Count: 5}
	counter.Increment()     // メソッド内では変更されたが、元のcounter.Countは変わらない
	fmt.Println("In main:", counter.Count)
}
Inside Increment: 6
In main: 5

ポインタレシーバの特徴

ポインタレシーバを使うと、メソッド内で構造体のフィールドを直接変更することが可能です。

値をコピーするオーバーヘッドを避けたい場合にも利用されます。

以下はポインタレシーバを利用する例です。

package main
import "fmt"
// Counter はカウンターを表す構造体
type Counter struct {
	Count int
}
// IncrementPointer はポインタレシーバを使用して元の値を変更する
func (c *Counter) IncrementPointer() {
	c.Count++
	fmt.Println("Inside IncrementPointer:", c.Count)
}
func main() {
	counter := Counter{Count: 5}
	counter.IncrementPointer() // 元のcounter.Countが変更される
	fmt.Println("In main:", counter.Count)
}
Inside IncrementPointer: 6
In main: 6

メソッドシグネチャの構成

メソッドのシグネチャは関数の場合とほぼ同じで、以下の要素で構成されます。

  • レシーバ
  • メソッド名
  • 引数
  • 戻り値

シグネチャの例は以下の通りです。

func (receiver Type) MethodName(param1 Type1, param2 Type2) ReturnType {
    // 処理内容
}

この形式により、対象の型に対して独自の挙動を定義することができます。

メソッドの呼び出し

基本的な呼び出し方法

メソッドは該当する型の変数から直接呼び出すことができます。

メソッド呼び出しの際に、値レシーバかポインタレシーバかは自動的に適用されるため、呼び出し方法自体に違いはありません。

以下は基本的な呼び出し方法の例です。

package main
import "fmt"
// Rectangle は長方形を表す構造体
type Rectangle struct {
	Width  float64
	Height float64
}
// Area はRectangle型のメソッド。面積を計算する
func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}
func main() {
	rect := Rectangle{Width: 5, Height: 3}
	// 面積を求めるメソッドの呼び出し
	area := rect.Area()
	fmt.Println("Area:", area)
}
Area: 15

構造体とメソッドの連携活用

データと振る舞いの統合

実装例による連携

構造体とメソッドを組み合わせることで、データとその振る舞いをひとまとめに扱うことができます。

以下の例では、BankAccountという構造体に対して入出金処理のメソッドを定義し、データと処理を統合しています。

package main
import "fmt"
// BankAccount は口座情報を表す構造体
type BankAccount struct {
	Owner   string
	Balance float64
}
// Deposit は口座に入金するメソッド
func (b *BankAccount) Deposit(amount float64) {
	b.Balance += amount
	fmt.Printf("%sさん、%.2f円入金しました。現在の残高は %.2f円です。\n", b.Owner, amount, b.Balance)
}
// Withdraw は口座から出金するメソッド
func (b *BankAccount) Withdraw(amount float64) {
	b.Balance -= amount
	fmt.Printf("%sさん、%.2f円出金しました。現在の残高は %.2f円です。\n", b.Owner, amount, b.Balance)
}
func main() {
	account := BankAccount{Owner: "Daisuke", Balance: 1000}
	account.Deposit(500)
	account.Withdraw(300)
}
Daisukeさん、500.00円入金しました。現在の残高は 1500.00円です。
Daisukeさん、300.00円出金しました。現在の残高は 1200.00円です。

埋め込み構造体の活用

埋め込みによる拡張手法

埋め込み構造体(匿名フィールド)を利用すると、ある構造体のフィールドやメソッドを別の構造体に取り込み、機能を拡張することができます。

継承のようなシンプルな実装が可能です。

以下は埋め込みによる拡張手法の例です。

package main
import "fmt"
// Animal は動物の基本情報を表す構造体
type Animal struct {
	Species string
}
// Speak はAnimal型のメソッド。動物の鳴き声を出力する
func (a Animal) Speak() {
	fmt.Println("Sound from", a.Species)
}
// Dog はAnimalを埋め込んだ構造体
type Dog struct {
	Animal // Animalを埋め込み
	Breed  string
}
func main() {
	// Dog構造体はAnimalのフィールドとメソッドを継承
	dog := Dog{
		Animal: Animal{Species: "Canine"},
		Breed:  "Bulldog",
	}
	// 埋め込んだメソッドの呼び出し
	dog.Speak()
	fmt.Println("Breed:", dog.Breed)
}
Sound from Canine
Breed: Bulldog

応用例

複数構造体間の連携

関連メソッドの組み合わせ

複数の構造体とそれぞれのメソッドを連携させると、より複雑な動作を実現することができます。

例えば、注文(Order)と商品の情報(Product)に対して、注文処理のメソッドと商品情報の更新メソッドを組み合わせる例を考えてみます。

package main
import "fmt"
// Product は商品情報を表す構造体
type Product struct {
	ID    int
	Name  string
	Stock int
}
// Order は注文情報を表す構造体
type Order struct {
	OrderID   int
	ProductID int
	Quantity  int
}
// ProcessOrder は注文処理を行うメソッド
func (o Order) ProcessOrder(p *Product) {
	if p.Stock >= o.Quantity {
		p.Stock -= o.Quantity
		fmt.Printf("Order %d processed. Remaining stock of %s: %d.\n", o.OrderID, p.Name, p.Stock)
	} else {
		fmt.Printf("Order %d failed. Insufficient stock of %s.\n", o.OrderID, p.Name)
	}
}
func main() {
	product := Product{ID: 1, Name: "Smartphone", Stock: 10}
	order := Order{OrderID: 1001, ProductID: 1, Quantity: 3}
	order.ProcessOrder(&product)
}
Order 1001 processed. Remaining stock of Smartphone: 7.

実践コードの分析

サンプルコードの解説

以下のサンプルコードは、構造体とメソッドを組み合わせた実践的な例です。

ここでは、Calculator構造体とそのメソッドを通じて基本的な算術計算を実行しています。

計算処理がメソッドとして定義されているため、データ(計算対象)と振る舞い(計算処理)が一体となっています。

package main
import "fmt"
// Calculator は計算を行う構造体
type Calculator struct {
	Value float64
}
// Add は加算を行うメソッド
func (c *Calculator) Add(num float64) {
	c.Value += num
}
// Subtract は減算を行うメソッド
func (c *Calculator) Subtract(num float64) {
	c.Value -= num
}
// Multiply は乗算を行うメソッド
func (c *Calculator) Multiply(num float64) {
	c.Value *= num
}
// Divide は除算を行うメソッド。ゼロ除算には注意する
func (c *Calculator) Divide(num float64) {
	// ゼロチェック \(num = 0 \)の場合は計算しない
	if num != 0 {
		c.Value /= num
	} else {
		fmt.Println("Error: Division by zero")
	}
}
func main() {
	calc := Calculator{Value: 10}
	calc.Add(5)       // 10 + 5 = 15
	calc.Subtract(3)  // 15 - 3 = 12
	calc.Multiply(2)  // 12 * 2 = 24
	calc.Divide(4)    // 24 / 4 = 6
	fmt.Println("Result:", calc.Value)
}
Result: 6

まとめ

この記事では、Go言語の構造体とメソッドの基本について、構造体の定義方法やフィールドの型指定、リテラルやゼロ値での初期化法を学ぶことができます。

また、レシーバを使ったメソッドの定義、値レシーバとポインタレシーバの違いやメソッドシグネチャの構成、基本的な呼び出し方法についても理解できる内容となっています。

さらに、構造体とメソッドを連携させた実装例や埋め込み構造体を活用した拡張手法、複数構造体間の関連メソッド組み合わせについて実践的に説明しているため、実用的なコーディング技術の向上に役立ちます。

2025-02-19更新日: 2025-02-19

関連記事

Go言語のinterfaceを関数の引数として使用する方法

Go言語のinterface引数の使い方を解説

2025-02-20
Go言語でクラスに相当する機能を実現する方法

Go言語の構造体とインターフェースによるクラス風実装について解説

2025-02-19
Go言語で構造体の配列からデータを検索する方法

Go言語における構造体配列検索の基本と実装方法を解説

2025-02-19
Go言語で構造体をコピーする方法と注意点

Go言語の構造体コピーの基本と注意点について解説

2025-02-19
Go言語の構造体をポインタとして扱う方法

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

2025-02-19
Go言語で構造体の継承を実現する方法

Go言語の構造体継承について解説 ― 埋め込みを活用した実装例

2025-02-19
Go言語でinterfaceを継承する方法と応用例

Go言語のInterface継承について解説：基本概念と実装例

2025-02-20
Go言語で構造体をJSON形式に変換する方法

Go言語の構造体を利用したJSON処理について解説

2025-02-19
Go言語で構造体を初期化する方法

Go言語の構造体初期化方法について解説

2025-02-19
Go言語のinterfaceと構造体の組み合わせ方

Go言語のInterfaceと構造体：柔軟な設計を実現する活用法を解説

2025-02-20
Back to top button
目次へ