月: 2017年11月

データ型の判定は switch 文でもできる。これを型switchという。一般的な書式はこう。

switch v := x.(type) {
    case 型1: 処理
    case 型2: 処理
    ...
    default: 処理
}

一昨日書いた型アサーションと似ているけど、カッコの中には type と書く。すると対応する型の case 節が実行される。

package main

import "fmt"

type Num interface {
    number()
}

type Int int

func (n Int) number() {}

type Real float64

func (n Real) number() {}

func sumOfNum(ary []Num) (Int, Real) {
    var sumi Int = 0
    var sumr Real = 0.0
    for _, x := range ary {
        switch v := x.(type) {
            case Int: sumi += v
            case Real: sumr += v
       }
    }
    return sumi, sumr
}

func main() {
    var ary[]Num = []Num{
        Int(1),
        Real(1.1),
        Int(2),
        Real(2.2),
        Int(3),
        Real(3.3),
    }
    a, b := sumOfNum(ary)
    fmt.Println(a, b)
}

^o^ > go run type_switch.go
6 6.6

空インターフェイスとは、定義すべきメソッドを持たないインターフェイスのことだ。言い換えるとどんな型にも当てはまる。空インターフェイスの配列やスライスはどんな型でも格納することができる。下の例ではスライス a に整数、実数、文字列を格納している。
Go は静的型付け言語なので、スライスに格納されているのが何の型なのかわからないのでは都合が悪い。そこで、型をチェックする機能がある。それが型アサーションだ。型アサーションは「変数.(型)」という書き方をして、変数が型と一致すればその値と true の2つの値が返ってくる。一致しなければゼロ値と false だ。下の例では、この型アサーションを使って、スライスに含まれる整数と実数のそれぞれの合計を求めている。

package main

import "fmt"

func sumOfInt(ary []interface{}) int {
    sum := 0
    for _, x := range ary {
        v, ok := x.(int)
        if ok {
            sum += v
        }
    }
    return sum
}

func sumOfFloat(ary []interface{}) float64 {
    sum := 0.0
    for _, x := range ary {
        v, ok := x.(float64)
        if ok {
            sum += v
        }
    }
    return sum
}

func main() {
    a := []interface{}{ 1, 1.1, "abc", 2, 2.2, "def", 3, 3.3 }
    fmt.Println(sumOfInt(a))
    fmt.Println(sumOfFloat(a))
}

^o^ > go run interface3.go
6
6.6

インターフェイスとは、異なる型の構造体を同じ型として扱うための抽象型のようなものだ。Java のインターフェイスと同様らしいけど Java のことはよく知らない。インターフェイスにはメソッドの型だけが定義されていて、そのメソッドすべてを実装した構造体はインターフェイスの型として扱えるようになる。

次の例では、インターフェイス Point を定義している。Point 型は distance0 というメソッドを持っている。Point2d と Point3d というのが具体的な構造体で、そのどちらもが distance0 メソッドを実装しているので、Point 型として1つのスライスに格納されている。

package main

import (
    "fmt"
    "math"
)

type Point interface {
    distance0() float64
}

type Point2d struct {
    x, y float64
}

func newPoint2d(x, y float64) *Point2d {
    p := new(Point2d)
    p.x, p.y = x, y
    return p
}

func (p *Point2d) distance0() float64 {
    return math.Sqrt(p.x * p.x + p.y * p.y)
}

type Point3d struct {
    x, y, z float64
}

func newPoint3d(x, y, z float64) *Point3d {
    p := new(Point3d)
    p.x, p.y, p.z = x, y, z
    return p
}

func (p *Point3d) distance0() float64 {
    return math.Sqrt(p.x * p.x + p.y * p.y + p.z * p.z)
}

func sumOfDistance0(ary []Point) float64 {
    sum := 0.0
    for _, p := range ary {
        sum += p.distance0()
    }
    return sum
}

func main() {
    a := []Point{
        newPoint2d(0, 0),
        newPoint2d(10, 10),
        newPoint3d(0, 0, 0),
        newPoint3d(10, 10, 10),
    }

    fmt.Println(a[0].distance0())
    fmt.Println(a[1].distance0())
    fmt.Println(a[2].distance0())
    fmt.Println(a[3].distance0())
    fmt.Println(sumOfDistance0(a))
}

^o^ > go run interface.go
0
14.142135623730951
0
17.320508075688775
31.462643699419726

Go はオブジェクト指向言語ではないけど、「構造体の埋め込み」という機能によって、似たようなことができる。
例を見てみよう。構造体 Bar にはフィールド foo として構造体 Foo が指定されている。これは単に、フィールドが構造体なだけであって、埋め込みとは言わない。一方、構造体 Baz にはフィールド名を省略して Foo が指定されている。これを匿名フィールドと言って、Baz には Foo のフィールドやメソッドが引き継がれる。これを構造体の埋め込みという。

package main

import "fmt"

type Foo struct {
    a, b int
}

func (x Foo) printA() {
    fmt.Println("a =", x.a)
}

func (x Foo) printB() {
    fmt.Println("b =", x.b)
}

type Bar struct {
    foo Foo
    c int
}

func (x Bar) printC() {
    fmt.Println("c =", x.c)
}

type Baz struct {
    Foo
    c int
}

func (x Baz) printB() {
    fmt.Print("Baz:")
    x.Foo.printB()
}

func (x Baz) printC() {
    fmt.Println("c =", x.c)
}

func main() {
    x := Foo{ 1,2 }
    y := Bar{ Foo{ 10,20 }, 30 }
    z := Baz{ Foo{ 100,200 }, 300 }

    x.printA()
    x.printB()
    y.foo.printA()
    // y.printA() エラー
    y.foo.printB()
    // y.printB() エラー
    y.printC()
    z.printA()
    z.printB()
    z.printC()
}

変数 y は構造体 Bar で、Foo を埋め込んでいないので、y.printA() のようなメソッド呼び出しはできない。一方、変数 z は Foo を埋め込んでいるので、z.printA() のように Foo のメソッドを呼び出すことができる。

o^ > go run struct_embed.go
a = 1
b = 2
a = 10
b = 20
c = 30
a = 100
Baz:b = 200
c = 300

複数の構造体を埋め込むこともできる。ただし、埋め込んだ構造体同士でフィールド名やメソッド名が重複すると、やや面倒になる。次の例では、構造体 Baz には Foo と Bar が埋め込んであるけど、フィールド a とメソッド printA が重複している。こういう時は構造体名を明示して呼び出さなければならない。

package main

import "fmt"

type Foo struct {
    a, b int
}

func (p *Foo) printA() {
    fmt.Println(p.a)
}

func (p *Foo) printB() {
    fmt.Println(p.b)
}

type Bar struct {
    a, c int
}

func (p *Bar) printA() {
    fmt.Println(p.a)
}

func (p *Bar) printC() {
    fmt.Println(p.c)
}

type Baz struct {
    Foo
    Bar
}

func main() {
    x := new(Baz)
    x.Bar.a = 10
    x.b = 20
    x.c = 30
    x.Foo.printA()
    x.printB()
    x.printC()
}

^o^ > go run struct_embed2.go
0
20
30

連結リストとは、値を保持するセルが数珠つなぎになった構造、つまり Scheme のリストと同じ構造だ。
今日は構造体やメソッドの練習として、連結リストのプログラムを写経してみる。
書き忘れていたけど、Go の一連の勉強は↓このページに沿ってやっている。

cf. お気楽 Go 言語プログラミング入門 – M.Hiroi’s Home Page

連結リストがあるのはこのページの中ほど。

cf. お気楽 Go 言語プログラミング入門 構造体 – M.Hiroi’s Home Page

それじゃ、行ってみよう。

package main

import (
    "fmt"
)

type Cell struct {
    item int
    next *Cell
}

type List struct {
    top *Cell
}

func newCell(x int, cp *Cell) *Cell {
    c := new(Cell)
    c.item, c.next = x, cp
    return c
}

func newList() *List {
    lst := new(List)
    lst.top = new(Cell)
    return lst
}

func (cp *Cell) nthCell(n int) *Cell {
    i := -1
    for cp != nil {
        if i == n { return cp }
        i++
        cp = cp.next
    }
    return nil
}

func (lst *List) nth(n int) (int, bool) {
    cp := lst.top.nthCell(n)
    if cp == nil {
        return 0, false
    } else {
        return cp.item, true
    }
}

func (lst *List) insertNth(n, x int) bool {
    cp := lst.top.nthCell(n - 1)
    if cp == nil {
        return false
    } else {
        cp.next = newCell(x, cp.next)
        return true
    }
}

func (lst *List) deleteNth(n int) bool {
    cp := lst.top.nthCell(n - 1)
    if cp == nil || cp.next == nil {
        return false
    } else {
        cp.next = cp.next.next
        return true
    }
}

func (lst *List) isEmpty() bool {
    return lst.top.next == nil
}

func (lst *List) printList() {
    cp := lst.top.next
    for ; cp != nil; cp = cp.next {
        fmt.Print(cp.item, " ")
    }
    fmt.Println("")
}

func main() {
    a := newList()
    for i := 0; i < 4; i++ {
        fmt.Println(a.insertNth(i, i))
    }
    a.printList()
    for i := 0; i < 5; i++ {
        n, ok := a.nth(i)
        fmt.Println(n, ok)
    }
    for !a.isEmpty() {
        a.deleteNth(0)
        a.printList()
    }
}

それほど難しくはない。ちょっと注意が必要なのは、List 構造体の top フィールドに入っている Cell 構造体はダミーで、その次の Cell が0番目の Cell になってるってところかな。
実行結果：

^o^ > go run linkedlist.go
true
true
true
true
0 1 2 3
0 true
1 true
2 true
3 true
0 false
1 2 3
2 3
3

うまくいった。

メソッドは、構造体（の型）と結びつけられた関数だ。Go はオブジェクト指向プログラミング言語ではないけど、このメソッドや構造体の埋め込み（これについては後で書くつもり）によって、オブジェクト指向的なプログラミングができるようになっている。
例を挙げよう。
前のエントリでは平面上の点を表す Point 構造体と、2点間の距離を求める distance 関数を作った。ここでもう一つ、3次元空間の点を表す Point3d 構造体を作る。この2点間の距離を求める関数を考えたとき、distance という名前は使えない。すでに名前を使ってしまっているからだ。
ところが、これらをそれぞれの構造体のメソッドにすれば、両方とも distance という名前にできる。
メソッドの一般亭な定義は次の通り。

func (仮引数 *型) 関数名(仮引数, ...) {
    処理
}

ここで、関数名の前のカッコの中にある仮引数をレシーバと言い、このメソッドはレシーバの型と結びつけられる。これで、Point と Point3d の両方の構造体に、同じ distance という名前のメソッドが定義できるわけだ。
実際に書いてみよう。

package main

import (
    "fmt"
    "math"
)

type Point struct {
    x, y float64
}

type Point3d struct {
    x, y, z float64
}

func newPoint(x, y float64) *Point {
    p := new(Point)
    p.x, p.y = x, y
    return p
}

func newPoint3d(x, y, z float64) *Point3d {
    p := new(Point3d)
    p.x, p.y, p.z = x, y, z
    return p
}

func (p *Point) distance(q *Point) float64 {
    dx := p.x - q.x
    dy := p.y - q.y
    return math.Sqrt(dx * dx + dy * dy)
}

func (p *Point3d) distance(q *Point3d) float64 {
    dx := p.x - q.x
    dy := p.y - q.y
    dz := p.z - q.z
    return math.Sqrt(dx * dx + dy * dy + dz * dz)
}

func main() {
    p1 := newPoint(0.0, 0.0)
    p2 := newPoint(10.0, 10.0)
    q1 := newPoint3d(0.0, 0.0, 0.0)
    q2 := newPoint3d(10.0, 10.0, 10.0)

    fmt.Println(p1.distance(p2))
    fmt.Println(q1.distance(q2))
}

^o^ > go run method.go
14.142135623730951
17.320508075688775