Go言語入門：よくある質問 -Types Vol.2-

本日は、Go言語のよくある質問 について解説しています。

背景

Go言語を学んでいると「なんでこんな仕様になっているんだろう？」「他の言語と違うのはなぜ？」といった疑問が湧いてきませんか。Go言語の公式サイトにあるFAQページには、そんな疑問に対する開発チームからの丁寧な回答がたくさん載っているんです。ただ、英語で書かれているため読むのに少しハードルがあるのも事実で、今回はこのFAQを日本語に翻訳して、Go言語への理解を深めていけたらと思い、これを読んだ時の内容を備忘として残しました。

型

メソッドの動的ディスパッチはどのように取得しますか？

動的にディスパッチされるメソッドを持つ唯一の方法は、インターフェースを通してです。構造体やその他の具象型のメソッドは常に静的に解決されます。

解説

この節では、Go言語におけるメソッドの動的ディスパッチ（実行時に適切なメソッドを選択する仕組み）について、その実現方法と制限を説明しています。

動的ディスパッチとは

静的ディスパッチ vs 動的ディスパッチ

// 静的ディスパッチ（コンパイル時に決定）
type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return d.Name + "がワンワン鳴いています"
}

func main() {
    dog := Dog{Name: "ポチ"}
    // コンパイル時に Dog.Speak() の呼び出しが確定
    fmt.Println(dog.Speak())  // 静的ディスパッチ
}

Go言語での動的ディスパッチ

インターフェースを使用した動的ディスパッチ

// インターフェースの定義
type Animal interface {
    Speak() string
    Move() string
}

// 異なる型が同じインターフェースを実装
type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return d.Name + "がワンワン鳴いています"
}

func (d Dog) Move() string {
    return d.Name + "が走っています"
}

type Cat struct {
    Name string
}

func (c Cat) Speak() string {
    return c.Name + "がニャーニャー鳴いています"
}

func (c Cat) Move() string {
    return c.Name + "が忍び足で歩いています"
}

// 動的ディスパッチの実例
func makeSound(animal Animal) {
    // 実行時に適切なメソッドが選択される
    fmt.Println(animal.Speak())  // 動的ディスパッチ
    fmt.Println(animal.Move())   // 動的ディスパッチ
}

func main() {
    animals := []Animal{
        Dog{Name: "ポチ"},
        Cat{Name: "タマ"},
    }
    
    for _, animal := range animals {
        makeSound(animal)  // 実行時に型に応じたメソッドが呼ばれる
    }
}

具象型での静的解決

構造体でのメソッド呼び出し

type Vehicle struct {
    Brand string
}

func (v Vehicle) Start() {
    fmt.Printf("%sが始動しました\n", v.Brand)
}

type Car struct {
    Vehicle
    Doors int
}

// Car 独自のメソッド
func (c Car) Start() {
    fmt.Printf("%sの車（%dドア）が始動しました\n", c.Brand, c.Doors)
}

func main() {
    car := Car{
        Vehicle: Vehicle{Brand: "Toyota"},
        Doors:   4,
    }
    
    // 静的ディスパッチ - コンパイル時に決定
    car.Start()         // Car.Start() が呼ばれる
    car.Vehicle.Start() // Vehicle.Start() が呼ばれる
    
    // 埋め込まれた型も静的に解決
    var vehicle Vehicle = car.Vehicle
    vehicle.Start()     // Vehicle.Start() が呼ばれる（静的）
}

実行時型情報による動的ディスパッチの仕組み

インターフェース値の内部構造

// インターフェース値は以下の情報を保持
// - 型情報（type information）
// - 値のポインタ（value pointer）
// - メソッドテーブル（method table）

func demonstrateInterfaceInternals() {
    var animal Animal
    
    // 具象型を代入
    animal = Dog{Name: "ポチ"}
    
    // 実行時に型情報を確認
    fmt.Printf("型: %T\n", animal)  // 型: main.Dog
    
    // 型アサーションによる型の確認
    if dog, ok := animal.(Dog); ok {
        fmt.Printf("これは犬です: %s\n", dog.Name)
    }
    
    // 型スイッチによる型別処理
    switch v := animal.(type) {
    case Dog:
        fmt.Printf("犬の特別な処理: %s\n", v.Name)
    case Cat:
        fmt.Printf("猫の特別な処理: %s\n", v.Name)
    }
}

メソッドテーブルの概念

// Goランタイムが内部的に管理するメソッドテーブル（概念的）
// 
// Animal インターフェースのメソッドテーブル:
// Dog型の場合:
//   Speak() -> Dog.Speak のアドレス
//   Move()  -> Dog.Move のアドレス
//
// Cat型の場合:
//   Speak() -> Cat.Speak のアドレス
//   Move()  -> Cat.Move のアドレス

func explainMethodDispatch() {
    animals := []Animal{
        Dog{Name: "ポチ"},
        Cat{Name: "タマ"},
    }
    
    for _, animal := range animals {
        // ランタイムがメソッドテーブルを参照して
        // 適切なメソッドを呼び出す
        animal.Speak()  // 動的ディスパッチ
    }
}

複数インターフェースの実装

同一型が複数インターフェースを満たす例

// 異なるインターフェース
type Speaker interface {
    Speak() string
}

type Mover interface {
    Move() string
}

type Pet interface {
    GetName() string
}

// 一つの型が複数のインターフェースを実装
type Robot struct {
    Name string
    Model string
}

func (r Robot) Speak() string {
    return r.Name + "です。モデル" + r.Model + "です。"
}

func (r Robot) Move() string {
    return r.Name + "がモーターで移動しています"
}

func (r Robot) GetName() string {
    return r.Name
}

// 異なるコンテキストで使用
func testDifferentInterfaces() {
    robot := Robot{Name: "R2D2", Model: "Astromech"}
    
    // 同じオブジェクトを異なるインターフェースとして使用
    var speaker Speaker = robot
    var mover Mover = robot
    var pet Pet = robot
    
    fmt.Println(speaker.Speak())  // 動的ディスパッチ
    fmt.Println(mover.Move())     // 動的ディスパッチ
    fmt.Println(pet.GetName())    // 動的ディスパッチ
}

空のインターフェース（interface{}）

任意の型を受け取る動的ディスパッチ

// interface{} は任意の型を保持可能
func processAnyValue(value interface{}) {
    // 型アサーションによる動的処理
    switch v := value.(type) {
    case string:
        fmt.Printf("文字列: %s\n", v)
    case int:
        fmt.Printf("整数: %d\n", v)
    case Dog:
        fmt.Printf("犬: %s\n", v.Speak())
    case Animal:  // インターフェース型も判定可能
        fmt.Printf("動物: %s\n", v.Speak())
    default:
        fmt.Printf("未知の型: %T\n", v)
    }
}

func demonstrateEmptyInterface() {
    values := []interface{}{
        "Hello World",
        42,
        Dog{Name: "ポチ"},
        Cat{Name: "タマ"},
    }
    
    for _, value := range values {
        processAnyValue(value)  // 各値の型に応じた処理
    }
}

動的ディスパッチの性能特性

静的 vs 動的の性能比較

// 性能計測の例
func benchmarkStaticDispatch(b *testing.B) {
    dog := Dog{Name: "ポチ"}
    
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = dog.Speak()  // 静的ディスパッチ（高速）
    }
}

func benchmarkDynamicDispatch(b *testing.B) {
    var animal Animal = Dog{Name: "ポチ"}
    
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = animal.Speak()  // 動的ディスパッチ（若干のオーバーヘッド）
    }
}

// 一般的な結果:
// - 静的ディスパッチ: 直接関数呼び出し
// - 動的ディスパッチ: ポインタ参照 + 関数呼び出し
// 実用的には性能差はほとんど気にならないレベル

実用的な設計パターン

Strategy パターンの実装

// 戦略インターフェース
type SortStrategy interface {
    Sort([]int) []int
}

// 具体的な戦略
type QuickSort struct{}

func (qs QuickSort) Sort(data []int) []int {
    // クイックソートの実装
    fmt.Println("クイックソートで並び替え")
    return data  // 簡略化
}

type BubbleSort struct{}

func (bs BubbleSort) Sort(data []int) []int {
    // バブルソートの実装
    fmt.Println("バブルソートで並び替え")
    return data  // 簡略化
}

// コンテキスト
type Sorter struct {
    strategy SortStrategy
}

func (s *Sorter) SetStrategy(strategy SortStrategy) {
    s.strategy = strategy
}

func (s *Sorter) Sort(data []int) []int {
    return s.strategy.Sort(data)  // 動的ディスパッチ
}

func demonstrateStrategy() {
    sorter := &Sorter{}
    data := []int{3, 1, 4, 1, 5}
    
    // 実行時に戦略を変更
    sorter.SetStrategy(QuickSort{})
    sorter.Sort(data)
    
    sorter.SetStrategy(BubbleSort{})
    sorter.Sort(data)
}

ファクトリーパターンでの動的ディスパッチ

// 共通インターフェース
type DatabaseDriver interface {
    Connect(connectionString string) error
    Query(sql string) ([]string, error)
    Close() error
}

// 具体的な実装
type MySQLDriver struct{}
type PostgreSQLDriver struct{}

func (m MySQLDriver) Connect(cs string) error {
    fmt.Println("MySQL に接続")
    return nil
}

func (m MySQLDriver) Query(sql string) ([]string, error) {
    fmt.Println("MySQL でクエリ実行:", sql)
    return []string{}, nil
}

func (m MySQLDriver) Close() error {
    fmt.Println("MySQL 接続を閉じる")
    return nil
}

// PostgreSQL の実装も同様...

// ファクトリー関数
func CreateDriver(driverType string) DatabaseDriver {
    switch driverType {
    case "mysql":
        return MySQLDriver{}
    case "postgresql":
        return PostgreSQLDriver{}
    default:
        return nil
    }
}

func demonstrateFactory() {
    // 実行時にドライバータイプを決定
    driverType := "mysql"  // 設定ファイルや環境変数から取得
    
    driver := CreateDriver(driverType)
    if driver != nil {
        driver.Connect("connection_string")  // 動的ディスパッチ
        driver.Query("SELECT * FROM users")  // 動的ディスパッチ
        driver.Close()                       // 動的ディスパッチ
    }
}

Go言語における動的ディスパッチは、インターフェースを通じてのみ実現され、この制約により型安全性を保ちながら柔軟なポリモーフィズムを提供しています。

おわりに 

本日は、Go言語のよくある質問について解説しました。