投稿者: takatoh

ファイル入出力はファイルディスクリプタを介して行う。要するにファイルをオープンしてファイルディスクリプタを取得し、使い終わったらクローズする、ってわけだ。
ただし、標準入出力に関しては最初から os パッケージに用意されている。

• os.Stdin: 標準入力
• os.Stdout: 標準出力
• os.Stderr: 標準エラー出力

標準入力から読み込むには os.Stdin.Read 関数、出力するには os.Stdout.Write または os.Stderr.Write 関数を使う。
ちょっと試してみよう。次のプログラムは、標準入力から受け取った文字列をそのまま標準出力に書き出す（ctrl + C で終了）。

package main

import "os"

func main() {
    buff := make([]byte, 256)
    for {
        c, _ := os.Stdin.Read(buff)
        if c == 0 { break }
        os.Stdout.Write(buff[:c])
    }
}

^o^ > go run echo.go
hello
hello

ひとつめの hello がキーボードからの入力で、ふたつめの hello が返ってきた出力だ。

今日は、練習のため二分探索木の写経をする。

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

package main

import "fmt"

type Item interface {
    Eq(Item) bool
    Less(Item) bool
}

type Node struct {
    item Item
    left, right *Node
}

func newNode(x Item) *Node {
    p := new(Node)
    p.item = x
    return p
}

func searchNode(node *Node, x Item) bool {
    for node != nil {
        switch {
            case x.Eq(node.item): return true
            case x.Less(node.item): node = node.left
            default: node = node.right
        }
    }
    return false
}

func insertNode(node *Node, x Item) *Node {
    switch {
        case node == nil: return newNode(x)
        case x.Eq(node.item): return node
        case x.Less(node.item):
            node.left = insertNode(node.left, x)
        default:
            node.right = insertNode(node.right, x)
    }
    return node
}

func searchMin(node *Node) Item {
    if node.left == nil {
        return node.item
    }
    return searchMin(node.left)
}

func deleteMin(node *Node) *Node {
    if node.left == nil {
        return node.right
    }
    node.left = deleteMin(node.left)
    return node
}

func deleteNode(node *Node, x Item) *Node {
    if node != nil {
        if x.Eq(node.item) {
            if node.left == nil {
                return node.right
            } else if node.right == nil {
                return node.left
            } else {
                node.item = searchMin(node.right)
                node.right = deleteMin(node.right)
            }
        } else if x.Less(node.item) {
            node.left = deleteNode(node.left, x)
        } else {
            node.right = deleteNode(node.right, x)
        }
    }
    return node
}

func foreachNode(f func(Item), node *Node) {
    if node != nil {
        foreachNode(f, node.left)
        f(node.item)
        foreachNode(f, node.right)
    }
}

type Tree struct {
    root *Node
}

func newTree() *Tree {
    return new(Tree)
}

func (t *Tree) searchTree(x Item) bool {
    return searchNode(t.root, x)
}

func (t *Tree) insertTree(x Item) {
    t.root = insertNode(t.root, x)
}

func (t *Tree) deleteTree(x Item) {
    t.root = deleteNode(t.root, x)
}

func (t *Tree) foreachTree(f func(Item)) {
    foreachNode(f, t.root)
}

func (t *Tree) printTree() {
    t.foreachTree(func(x Item) { fmt.Print(x, " ") })
    fmt.Println("")
}

type Int int

func (n Int) Eq(m Item) bool {
    return n == m.(Int)
}

func (n Int) Less(m Item) bool {
    return n < m.(Int)
}

func main() {
    a := newTree()
    for _, v := range []int { 5,6,4,7,3,8,2,9,1,0 } {
        a.insertTree(Int(v))
    }
    a.printTree()
    for i := 0; i < 10; i++ {
        fmt.Println(a.searchTree(Int(i)))
    }
    a.printTree()
    for i := 0; i < 10; i++ {
        a.deleteTree(Int(i)) a.printTree()
    }
}

探索木自体は Item 型（インターフェイス）を対象としている。このため int に Int という別名をつけて Eq と Less の2つのメソッドを定義している。わざわざ別名をつけているのは、通常の（構造体でない）型にはメソッドを定義できないため。

^o^ > go run binarytree.go
0 1 2 3 4 5 6 7 8 9
true
true
true
true
true
true
true
true
true
true
0 1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
2 3 4 5 6 7 8 9
3 4 5 6 7 8 9
4 5 6 7 8 9
5 6 7 8 9
6 7 8 9
7 8 9
8 9
9

構造体と同じく、インターフェイスも別のインターフェイスに埋め込むことができる。
下の例では、BazI に FooI と BarI を埋め込んでいる。すると、BazI を実装した構造体 Baz では、FooI と BarI のメソッドを、あたかも自分のメソッドのように使えるようになる。

package main

import "fmt"

type Foo struct {
    a int
}

type FooI interface {
    getA() int
}

func (p *Foo) getA() int {
    return p.a
}

type Bar struct {
    b int
}

type BarI interface {
    getB() int
}

func (p *Bar) getB() int {
    return p.b
}

type Baz struct {
    Foo
    Bar
}

type BazI interface {
    FooI
    BarI
}

func main() {
    a := []FooI{
        &Foo{1},
        &Foo{2},
        &Baz{},
    }
    b := []BarI{
        &Bar{10},
        &Bar{20},
        &Baz{},
    }
    c := []BazI{
        &Baz{},
        &Baz{Foo{1}, Bar{2}},
        &Baz{Foo{3}, Bar{4}},
    }
    for i := 0; i < 3; i++ {
        fmt.Println(a[i].getA())
        fmt.Println(b[i].getB())
        fmt.Println(c[i].getA())
        fmt.Println(c[i].getB())
    }
}

^o^ > go run interface_embed.go
1
10
0
0
2
20
1
2
0
0
3
4

データ型の判定は 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

うまくいった。