今回は、Structについて学びます。
StructもArray, Slice, Mapと同様にデータ構造体です。
しかし、Structは他のデータ構造とは違って「複数種類のタイプを格納できる」超便利なやつです。
Structは、あらゆるプログラムの中で使用される超重要項目であるため、しっかり学んでいきましょう。
学習記事まとめ
Structについて
Sliceはリスト形式で、MapはKey-Valueの形式で値を格納しました。この二つの構造体で共通している点が、「一つのタイプしか格納できないこと」です。
|
1 2 3 4 5 |
# sliceの宣言(単一のタイプでしかvalueを保持できない) mySlice := []string # mapの宣言(単一のタイプでしかkey, valueを保持できない) myMap := map[string]int |
しかし、Structにはその制約はありません。
Structは、複数の異なるタイプで構成することができるデータ構造体です。
|
1 2 3 4 5 6 7 |
# strctの宣言 struct { fields1 string fields2 int fields3 bool fields4 float64 } |
サンプルプログラムを書いてみます。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
package main import "fmt" func main() { var myStruct struct { name string age int men bool } fmt.Printf("%#v\n", myStruct) } |
|
1 2 3 |
$ go run main.go struct { name string; age int; men bool }{name:"", age:0, men:false} |
出力結果を見るとstructもSliceやMapと同様に基底typeのデフォルト値で初期化されていますね。
フィールドアクセス
Structの宣言はできたので、次は、フィールドにアクセスしてみます。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
package main import "fmt" func main() { var myStruct struct { name string age int men bool } myStruct.name = "Harry" myStruct.age = 30 myStruct.men = true fmt.Printf("%#v\n", myStruct) fmt.Println(myStruct.name) fmt.Println(myStruct.age) fmt.Println(myStruct.men) } |
|
1 2 3 4 5 6 7 |
$ go run main.go struct { name string; age int; men bool }{name:"Harry", age:30, men:true} Harry 30 true |
タイプとして宣言
ここまでのStructは大変便利そうに見えますが、複数宣言したいときは少し厄介です。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
package main import "fmt" func main() { var myStruct struct { name string age int men bool } myStruct.name = "Harry" myStruct.age = 30 myStruct.men = true fmt.Printf("%#v\n", myStruct) var myStruct2 struct { name string age int men bool } myStruct2.name = "Ron" myStruct2.age = 33 myStruct2.men = true fmt.Printf("%#v\n", myStruct2) } |
ご覧の通り、Structのプロパティが重複した状態で宣言する必要があります。これは、プログラムの観点から言うとイケてないです。
しかし、安心してください。ちゃんと回避策があります。
それは、Go言語のtypeを自分で作成するばいいのです。
Go言語には、string, int, bool, float64などの基底typeが存在しますが、自分でカスタムしたtypeを「type」キーワードで宣言することができます。
|
1 2 3 |
type myType struct { // fields here } |
typeにもスコープがあり、関数内に宣言してしまうとその関数内でしか使用することができません。その為、通常はパッケージレベルで宣言します。
先ほどのコードを書き換えてみます。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
package main import "fmt" type myStruct struct { name string age int men bool } func main() { var myStruct1 myStruct myStruct1.name = "Harry" myStruct1.age = 30 myStruct1.men = true fmt.Printf("%#v\n", myStruct1) var myStruct2 myStruct myStruct2.name = "Ron" myStruct2.age = 33 myStruct2.men = true fmt.Printf("%#v\n", myStruct2) } |
随分とスッキリしたことが分かると思います。
パラメータとして宣言
structは、パラメータとして宣言することもできます。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
package main import "fmt" type myStruct struct { name string age int men bool } func pullPersonalInfo(m myStruct) { fmt.Println("Name: ", m.name) fmt.Println("Age: ", m.age) fmt.Println("Men?: ", m.men) } func main() { var myStruct1 myStruct myStruct1.name = "Harry" myStruct1.age = 30 myStruct1.men = true pullPersonalInfo(myStruct1) } |
Structを受け取って、情報を出力するプログラムです。実行します。
|
1 2 3 4 5 |
$ go run main.go Name: Harry Age: 30 Men?: true |
逆にstructを返す実装をしてもいいかもです。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
package main import "fmt" type myStruct struct { name string age int men bool } func createPersonInfo(name string, age int, men bool) myStruct { var p myStruct p.name = name p.age = age p.men = men return p } func main() { p := createPersonInfo("Harry", 30, true) fmt.Println("Name: ", p.name) fmt.Println("Age: ", p.age) fmt.Println("Men?: ", p.men) } |
|
1 2 3 4 5 |
$ go run main.go Name: Harry Age: 30 Men?: true |
Structの値渡し
Structは、値渡しの挙動をとります。次のサンプルコードを見てください。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
package main import "fmt" type student struct { name string age int man bool } func setProperty(s student) { s.name = "Harry" s.age = 30 s.man = true } func main() { var s student setProperty(s) fmt.Println(s.name) fmt.Println(s.age) fmt.Println(s.man) } |
|
1 2 3 4 |
$ go run main.go 0 false |
setPropertyにstructを渡して値を設定しましたが、出力結果はそれぞれのtypeのデフォルト値になっています。
この挙動は、以前学習した「関数の引数の実態」と同じです。
setProperty関数の引数として渡されたのは、student Structをコピーしたもので、実態ではありません。
そうそう、これってバグになりやすいんだよな〜
…(それ、以前私が言いました…)
回避策は、「ポインタ」を使うことです。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
package main import "fmt" type student struct { name string age int man bool } func setProperty(s *student) { s.name = "Harry" s.age = 30 s.man = true } func main() { var s student setProperty(&s) fmt.Println(s.name) fmt.Println(s.age) fmt.Println(s.man) } |
|
1 2 3 4 5 |
$ go run main.go Harry 30 true |
簡単ですね。しかし、疑問が残ると思います。
前回とは違って、今回のコードは少し違っています。
前回のコードを以下に記載しますね。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package main import "fmt" // ポインタタイプで受け取る func double(amount *int) { *amount *= 2 fmt.Printf("amount in double function is %d\n", *amount) } func main() { amount := 6 double(&amount) fmt.Printf("amount in main function is %d\n", amount) } |
違いがわかるでしょうか？
わかったわ。double関数内のamount変数には*がついてるけど、setProperty関数内の各変数には*がついてない！どうやって動いているの？
ちょっと複雑なので少しずつ解説します。
まず、ポインタは変数のアドレスを指し示しています。
|
1 2 3 4 5 6 7 8 9 10 11 |
package main import "fmt" func main() { var value int = 1 // Get a pointer to the value var pointer *int = &value // Get Pointer Address fmt.Println(pointer) } |
|
1 2 3 |
$ go run main.go 0xc00007e000 |
アドレスではなく、値を取得したい場合は、pointerの頭に*をつけます。
|
1 2 3 4 5 6 7 8 9 10 11 |
package main import "fmt" func main() { var value int = 1 // Get a pointer to the value var pointer *int = &value // Get Pointer Address fmt.Println(*pointer) } |
|
1 2 3 |
$ go run main.go 1 |
こういった背景があり、structの変数にも*が必要ではないのか？といった疑問が湧いてきます。
しかし、structのポインタに*をつけると正しく動作しません。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
package main import "fmt" type student struct { name string age int man bool } func setProperty(s *student) { // attach * to struct pointer *s.name = "Harry" *s.age = 30 *s.man = true } func main() { var s student setProperty(&s) fmt.Println(s.name) fmt.Println(s.age) fmt.Println(s.man) } |
|
1 2 3 4 5 6 |
$ go run main.go # command-line-arguments ./main.go:13:2: invalid indirect of s.name (type string) ./main.go:14:2: invalid indirect of s.age (type int) ./main.go:15:2: invalid indirect of s.man (type bool) |
「*s.name」にした場合、Go言語は「name」がポインタであると判断してしまいますが、nameにはstringが宣言されているだけですので、エラーになります(他の変数も同様)。
つまり、次のように実装するとエラーが回避できます。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
package main import "fmt" type student struct { name string age int man bool } func setProperty(s *student) { // attach * to struct pointer (*s).name = "Harry" (*s).age = 30 (*s).man = true } func main() { var s student setProperty(&s) fmt.Println(s.name) fmt.Println(s.age) fmt.Println(s.man) } |
|
1 2 3 4 5 |
$ go run main.go Harry 30 true |
普通は、*なしで書きますけどね。
Structの外だし
Structを外部パッケージに外出ししてみましょう。
|
1 2 |
mkdir school touch school/person.go |
|
1 2 3 4 5 6 7 8 9 10 11 |
// school/person.go package school // To export this, its name must begin with a capital letter type Student struct { // its field name must begin with a capital letter too. Name string Age int Man bool } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
// main.go package main import ( "fmt" "github.com/school" ) func main() { var s school.Student s.Name = "Harry" s.Age = 30 s.Man = true fmt.Println(s) } |
|
1 2 3 |
$ go run main.go {Harry 30 true} |
注意点としては、Structの変数名とフィールド名の先頭は必ず大文字で始める必要があります。
先頭大文字で宣言することで、外部パッケージからの呼び出しが可能になるのです。
Structリテラル
Structリテラルを使えば、宣言&初期化が一度に行えます。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main import ( "fmt" "github.com/school" ) func main() { student := school.Student{Name: "Harry", Age: 30, Man: true} fmt.Println(student) } |
フィールドの共有
Structは便利な構造体で、どのようなtypeでも格納可能です。それはつまり、Structで宣言したtypeも格納可能であるということです。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// school/person.go package school type PersonalInfo struct { Name string Age int Man bool } type Student struct { StudentInfo PersonalInfo } type Teacher struct { TeacherInfo PersonalInfo } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// main.go package main import ( "fmt" "github.com/school" ) func main() { sPersonalInfo := school.PersonalInfo{Name: "Harry", Age: 15, Man: true} student := school.Student{StudentInfo: sPersonalInfo} fmt.Println(student.) tPersonalInfo := school.PersonalInfo{Name: "Snape", Age: 40, Man: true} teacher := school.Teacher{TeacherInfo: tPersonalInfo} fmt.Println(teacher) } |
|
1 2 3 4 |
$ go run main.go {{Harry 15 true}} {{Snape 40 true}} |
Anonymous Struct fields
Struct Typeを他のStructに入れると便利だということはわかりましたが、少しめんどくささも感じています。
例えば、次のサンプルコードでは、StudentInfoを跨いで値を格納していますが、少し見た目が悪いです。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
// main.go package main import ( "fmt" "github.com/school" ) func main() { student := school.Student{} student.StudentInfo.Name = "Harry" student.StudentInfo.Age = 15 student.StudentInfo.Man = true fmt.Println(student) } |
こういった場合にGo言語では、「anonymous fields」と呼ばれるStructフィールドが用意されています。
このフィールドを利用するとより簡単にプロパティへアクセスできます。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
// school/person.go package school type PersonalInfo struct { Name string Age int Man bool } type Student struct { PersonalInfo // change } type Teacher struct { PersonalInfo // change } |
PersonalInfoのフィールド名を削除しました。main.goも書き換えましょう。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
// main.go package main import ( "fmt" "github.com/school" ) func main() { student := school.Student{} student.Name = "Harry" student.Age = 15 student.Man = true fmt.Println(student) } |
ご覧の通り、StudentInfo無しででアクセス可能になりましたね。随分とスッキリしました。
まとめ
本項で学んだことをまとめます。
・ structキーワードで、Structを宣言する -> var myStruct struct {}
・ typeキーワードで、独自のtypeのstructを宣言できる
-> type myType struct{}
・ 「.」でプロパティにアクセスできる -> myStruct.field1 = “value”
・ Structが関数に渡される際、コピーされたものが渡される(値渡し)
・ 呼び出し元で宣言したstructを渡したい場合は、ポインタを用いる
・ Structを外部から呼び出したい場合は、名前の先頭を大文字にする
・ 同様にフィールド名も先頭大文字にする
・ Structリテラルで、宣言&初期化が行える -> myVar := myType{field: value}
・ Structには、anonymous fieldを宣言できる
次回
次回は、Typeの宣言についてより詳細に学んでいきましょう。
にほんブログ村
コメントを残す
コメントを投稿するにはログインしてください。