結構體定義的一般方式如下:
~~~
type identifier struct {
field1 type1
field2 type2
...
}
~~~
`type T struct {a, b int}`?也是合法的語法,它更適用于簡單的結構體。
結構體里的字段都有?**名字**,像 field1、field2 等,如果字段在代碼中從來也不會被用到,那么可以命名它為?**_**。
結構體的字段可以是任何類型,甚至是結構體本身(參考第?[10.5](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/10.5.md)?節),也可以是函數或者接口(參考第 11 章)。可以聲明結構體類型的一個變量,然后像下面這樣給它的字段賦值:
~~~
var s T
s.a = 5
s.b = 8
~~~
數組可以看作是一種結構體類型,不過它使用下標而不是具名的字段。
**使用 new**
使用?**new**?函數給一個新的結構體變量分配內存,它返回指向已分配內存的指針:`var t *T = new(T)`,如果需要可以把這條語句放在不同的行(比如定義是包范圍的,但是分配卻沒有必要在開始就做)。
~~~
var t *T
t = new(T)
~~~
寫這條語句的慣用方法是:`t := new(T)`,變量?`t`?是一個指向?`T`的指針,此時結構體字段的值是它們所屬類型的零值。
聲明?`var t T`?也會給?`t`?分配內存,并零值化內存,但是這個時候?`t`?是類型T。在這兩種方式中,`t`?通常被稱做類型 T 的一個實例(instance)或對象(Object)。
示例 10.1?[structs_fields.go](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/examples/chapter_10/structs_fields.go)?給出了一個非常簡單的例子:
~~~
package main
import "fmt"
type struct1 struct {
i1 int
f1 float32
str string
}
func main() {
ms := new(struct1)
ms.i1 = 10
ms.f1 = 15.5
ms.str= "Chris"
fmt.Printf("The int is: %d\n", ms.i1)
fmt.Printf("The float is: %f\n", ms.f1)
fmt.Printf("The string is: %s\n", ms.str)
fmt.Println(ms)
}
~~~
輸出:
~~~
The int is: 10
The float is: 15.500000
The string is: Chris
&{10 15.5 Chris}
~~~
使用?`fmt.Println`?打印一個結構體的默認輸出可以很好的顯示它的內容,類似使用?**%v**?選項。
就像在面向對象語言所作的那樣,可以使用點號符給字段賦值:`structname.fieldname = value`。
同樣的,使用點號符可以獲取結構體字段的值:`structname.fieldname`。
在 Go 語言中這叫?**選擇器(selector)**。無論變量是一個結構體類型還是一個結構體類型指針,都使用同樣的?**選擇器符(selector-notation)**?來引用結構體的字段:
~~~
type myStruct struct { i int }
var v myStruct // v是結構體類型變量
var p *myStruct // p是指向一個結構體類型變量的指針
v.i
p.i
~~~
初始化一個結構體實例(一個結構體字面量:struct-literal)的更簡短和慣用的方式如下:
~~~
ms := &struct1{10, 15.5, "Chris"}
// 此時ms的類型是 *struct1
~~~
或者:
~~~
var mt struct1
ms := struct1{10, 15.5, "Chris"}
~~~
混合字面量語法(composite literal syntax)`&struct1{a, b, c}`?是一種簡寫,底層仍然會調用?`new ()`,這里值的順序必須按照字段順序來寫。在下面的例子中能看到可以通過在值的前面放上字段名來初始化字段的方式。表達式?`new(Type)`和?`&Type{}`?是等價的。
時間間隔(開始和結束時間以秒為單位)是使用結構體的一個典型例子:
~~~
type Interval struct {
start int
end int
}
~~~
初始化方式:
~~~
intr := Interval{0, 3} (A)
intr := Interval{end:5, start:1} (B)
intr := Interval{end:5} (C)
~~~
在(A)中,值必須以字段在結構體定義時的順序給出,**&**?不是必須的。(B)顯示了另一種方式,字段名加一個冒號放在值的前面,這種情況下值的順序不必一致,并且某些字段還可以被忽略掉,就像(C)中那樣。
結構體類型和字段的命名遵循可見性規則(第?[4.2](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/04.2.md)?節),一個導出的結構體類型中有些字段是導出的,另一些不是,這是可能的。
下圖說明了結構體類型實例和一個指向它的指針的內存布局:
~~~
type Point struct { x, y int }
~~~
使用 new 初始化:
[](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/images/10.1_fig10.1-1.jpg?raw=true)
作為結構體字面量初始化:
[](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/images/10.1_fig10.1-2.jpg?raw=true)
類型 strcut1 在定義它的包 pack1 中必須是唯一的,它的完全類型名是:`pack1.struct1`。
下面的例子?[Listing 10.2—person.go](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/examples/person.go)?顯示了一個結構體 Person,一個方法,方法有一個類型為?`*Person`?的參數(因此對象本身是可以被改變的),以及三種調用這個方法的不同方式:
~~~
package main
import (
"fmt"
"strings"
)
type Person struct {
firstName string
lastName string
}
func upPerson(p *Person) {
p.firstName = strings.ToUpper(p.firstName)
p.lastName = strings.ToUpper(p.lastName)
}
func main() {
// 1-struct as a value type:
var pers1 Person
pers1.firstName = "Chris"
pers1.lastName = "Woodward"
upPerson(&pers1)
fmt.Printf("The name of the person is %s %s\n", pers1.firstName, pers1.lastName)
// 2—struct as a pointer:
pers2 := new(Person)
pers2.firstName = "Chris"
pers2.lastName = "Woodward"
(*pers2).lastName = "Woodward" // 這是合法的
upPerson(pers2)
fmt.Printf("The name of the person is %s %s\n", pers2.firstName, pers2.lastName)
// 3—struct as a literal:
pers3 := &Person{"Chris","Woodward"}
upPerson(pers3)
fmt.Printf("The name of the person is %s %s\n", pers3.firstName, pers3.lastName)
}
~~~
輸出:
~~~
The name of the person is CHRIS WOODWARD
The name of the person is CHRIS WOODWARD
The name of the person is CHRIS WOODWARD
~~~
在上面例子的第二種情況中,可以直接通過指針,像?`pers2.lastName="Woodward"`?這樣給結構體字段賦值,沒有像 C++ 中那樣需要使用?`->`?操作符,Go 會自動做這樣的轉換。
注意也可以通過解指針的方式來設置值:`(*pers2).lastName = "Woodward"`
**結構體的內存布局**
Go 語言中,結構體和它所包含的數據在內存中是以連續塊的形式存在的,即使結構體中嵌套有其他的結構體,這在性能上帶來了很大的優勢。不像 Java 中的引用類型,一個對象和它里面包含的對象可能會在不同的內存空間中,這點和 Go 語言中的指針很像。下面的例子清晰地說明了這些情況:
~~~
type Rect1 struct {Min, Max Point }
type Rect2 struct {Min, Max *Point }
~~~
[](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/images/10.1_fig10.2.jpg?raw=true)
**遞歸結構體**
結構體類型可以通過引用自身來定義。這在定義鏈表或二叉樹的元素(通常叫節點)時特別有用,此時節點包含指向臨近節點的鏈接(地址)。如下所示,鏈表中的?`su`,樹中的?`ri`?和?`le`?分別是指向別的節點的指針。
鏈表:
[](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/images/10.1_fig10.3.jpg?raw=true)
這塊的?`data`?字段用于存放有效數據(比如 float64),`su`?指針指向后繼節點。
Go 代碼:
~~~
type Node struct {
data float64
su *Node
}
~~~
鏈表中的第一個元素叫?`head`,它指向第二個元素;最后一個元素叫?`tail`,它沒有后繼元素,所以它的?`su`?為 nil 值。當然真實的鏈接會有很多數據節點,并且鏈表可以動態增長或收縮。
同樣地可以定義一個雙向鏈表,它有一個前趨節點?`pr`?和一個后繼節點?`su`:
~~~
type Node struct {
pr *Node
data float64
su *Node
}
~~~
二叉樹:
[](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/images/10.1_fig10.4.jpg?raw=true)
二叉樹中每個節點最多能鏈接至兩個節點:左節點(le)和右節點(ri),這兩個節點本身又可以有左右節點,依次類推。樹的頂層節點叫根節點(**root**),底層沒有子節點的節點叫葉子節點(**leaves**),葉子節點的?`le`?和?`ri`?指針為 nil 值。在 Go 中可以如下定義二叉樹:
~~~
type Tree strcut {
le *Tree
data float64
ri *Tree
}
~~~
**結構體轉換**
Go 中的類型轉換遵循嚴格的規則。當為結構體定義了一個 alias 類型時,此結構體類型和它的 alias 類型都有相同的底層類型,它們可以如示例 10.3 那樣互相轉換,同時需要注意其中非法賦值或轉換引起的編譯錯誤。
示例 10.3:
~~~
package main
import "fmt"
type number struct {
f float32
}
type nr number // alias type
func main() {
a := number{5.0}
b := nr{5.0}
// var i float32 = b // compile-error: cannot use b (type nr) as type float32 in assignment
// var i = float32(b) // compile-error: cannot convert b (type nr) to type float32
// var c number = b // compile-error: cannot use b (type nr) as type number in assignment
// needs a conversion:
var c = number(b)
fmt.Println(a, b, c)
}
~~~
輸出:
~~~
{5} {5} {5}
~~~
**練習 10.1**?vcard.go:
定義結構體 Address 和 VCard,后者包含一個人的名字、地址編號、出生日期和圖像,試著選擇正確的數據類型。構建一個自己的 vcard 并打印它的內容。
~~~
提示:
VCard 必須包含住址,它應該以值類型還是以指針類型放在 VCard 中呢?
第二種會好點,因為它占用內存少。包含一個名字和兩個指向地址的指針的 Address 結構體可以使用 %v 打印:
{Kersschot 0x126d2b80 0x126d2be0}
~~~
**練習 10.2**?persionext1.go:
修改 persionext1.go,使它的參數 upPerson 不是一個指針,解釋下二者的區別。
**練習 10.3**?point.go:
使用坐標 X、Y 定義一個二維 Point 結構體。同樣地,對一個三維點使用它的極坐標定義一個 Polar 結構體。實現一個`Abs()`?方法來計算一個 Point 表示的向量的長度,實現一個?`Scale`?方法,它將點的坐標乘以一個尺度因子(提示:使用`math`?包里的?`Sqrt`?函數)(function Scale that multiplies the coordinates of a point with a scale factor)。
**練習 10.3**?rectangle.go:
定義一個 Rectangle 結構體,它的長和寬是 int 類型,并定義方法?`Area()`?和?`Primeter()`,然后進行測試。
- 前言
- 第一部分:學習 Go 語言
- 第1章:Go 語言的起源,發展與普及
- 1.1 起源與發展
- 1.2 語言的主要特性與發展的環境和影響因素
- 第2章:安裝與運行環境
- 2.1 平臺與架構
- 2.2 Go 環境變量
- 2.3 在 Linux 上安裝 Go
- 2.4 在 Mac OS X 上安裝 Go
- 2.5 在 Windows 上安裝 Go
- 2.6 安裝目錄清單
- 2.7 Go 運行時(runtime)
- 2.8 Go 解釋器
- 第3章:編輯器、集成開發環境與其它工具
- 3.1 Go 開發環境的基本要求
- 3.2 編輯器和集成開發環境
- 3.3 調試器
- 3.4 構建并運行 Go 程序
- 3.5 格式化代碼
- 3.6 生成代碼文檔
- 3.7 其它工具
- 3.8 Go 性能說明
- 3.9 與其它語言進行交互
- 第二部分:語言的核心結構與技術
- 第4章:基本結構和基本數據類型
- 4.1 文件名、關鍵字與標識符
- 4.2 Go 程序的基本結構和要素
- 4.3 常量
- 4.4 變量
- 4.5 基本類型和運算符
- 4.6 字符串
- 4.7 strings 和 strconv 包
- 4.8 時間和日期
- 4.9 指針
- 第5章:控制結構
- 5.1 if-else 結構
- 5.2 測試多返回值函數的錯誤
- 5.3 switch 結構
- 5.4 for 結構
- 5.5 Break 與 continue
- 5.6 標簽與 goto
- 第6章:函數(function)
- 6.1 介紹
- 6.2 函數參數與返回值
- 6.3 傳遞變長參數
- 6.4 defer 和追蹤
- 6.5 內置函數
- 6.6 遞歸函數
- 6.7 將函數作為參數
- 6.8 閉包
- 6.9 應用閉包:將函數作為返回值
- 6.10 使用閉包調試
- 6.11 計算函數執行時間
- 6.12 通過內存緩存來提升性能
- 第7章:數組與切片
- 7.1 聲明和初始化
- 7.2 切片
- 7.3 For-range 結構
- 7.4 切片重組(reslice)
- 7.5 切片的復制與追加
- 7.6 字符串、數組和切片的應用
- 第8章:Map
- 8.1 聲明、初始化和 make
- 8.2 測試鍵值對是否存在及刪除元素
- 8.3 for-range 的配套用法
- 8.4 map 類型的切片
- 8.5 map 的排序
- 8.6 將 map 的鍵值對調
- 第9章:包(package)
- 9.1 標準庫概述
- 9.2 regexp 包
- 9.3 鎖和 sync 包
- 9.4 精密計算和 big 包
- 9.5 自定義包和可見性
- 9.6 為自定義包使用 godoc
- 9.7 使用 go install 安裝自定義包
- 9.8 自定義包的目錄結構、go install 和 go test
- 9.9 通過 Git 打包和安裝
- 9.10 Go 的外部包和項目
- 9.11 在 Go 程序中使用外部庫
- 第10章:結構(struct)與方法(method)
- 10.1 結構體定義
- 10.2 使用工廠方法創建結構體實例
- 10.3 使用自定義包中的結構體
- 10.4 帶標簽的結構體
- 10.5 匿名字段和內嵌結構體
- 10.6 方法
- 10.8 垃圾回收和 SetFinalizer
- 第11章:接口(interface)與反射(reflection)
- 11.1 接口是什么
- 11.2 接口嵌套接口
- 11.3 類型斷言:如何檢測和轉換接口變量的類型
- 11.4 類型判斷:type-switch
- 11.5 測試一個值是否實現了某個接口
- 11.6 使用方法集與接口
- 11.7 第一個例子:使用 Sorter 接口排序
- 11.8 第二個例子:讀和寫
- 11.9 空接口
- 11.10 反射包
- 第三部分:Go 高級編程
- 第12章 讀寫數據
- 12.1 讀取用戶的輸入
- 12.2 文件讀寫
- 12.3 文件拷貝
- 12.4 從命令行讀取參數
- 12.5 用buffer讀取文件
- 12.6 用切片讀寫文件
- 12.7 用 defer 關閉文件
- 12.8 使用接口的實際例子:fmt.Fprintf
- 12.9 Json 數據格式
- 12.10 XML 數據格式
- 12.11 用 Gob 傳輸數據
- 12.12 Go 中的密碼學
- 第13章 錯誤處理與測試
- 13.1 錯誤處理
- 13.2 運行時異常和 panic
- 13.3 從 panic 中恢復(Recover)
- 13.4 自定義包中的錯誤處理和 panicking
- 13.5 一種用閉包處理錯誤的模式
- 13.6 啟動外部命令和程序
- 13.7 Go 中的單元測試和基準測試
- 13.8 測試的具體例子
- 13.9 用(測試數據)表驅動測試
- 13.10 性能調試:分析并優化 Go 程序
- 第14章:協程(goroutine)與通道(channel)
- 14.1 并發、并行和協程
- 14.2 使用通道進行協程間通信
- 14.3 協程同步:關閉通道-對阻塞的通道進行測試
- 14.4 使用 select 切換協程
- 14.5 通道,超時和計時器(Ticker)
- 14.6 協程和恢復(recover)
- 第15章:網絡、模版與網頁應用
- 15.1 tcp服務器
- 15.2 一個簡單的web服務器
- 15.3 訪問并讀取頁面數據
- 15.4 寫一個簡單的網頁應用
- 第四部分:實際應用
- 第16章:常見的陷阱與錯誤
- 16.1 誤用短聲明導致變量覆蓋
- 16.2 誤用字符串
- 16.3 發生錯誤時使用defer關閉一個文件
- 16.5 不需要將一個指向切片的指針傳遞給函數
- 16.6 使用指針指向接口類型
- 16.7 使用值類型時誤用指針
- 16.8 誤用協程和通道
- 16.9 閉包和協程的使用
- 16.10 糟糕的錯誤處理
- 第17章:模式
- 17.1 關于逗號ok模式
- 第18章:出于性能考慮的實用代碼片段
- 18.1 字符串
- 18.2 數組和切片
- 18.3 映射
- 18.4 結構體
- 18.5 接口
- 18.6 函數
- 18.7 文件
- 18.8 協程(goroutine)與通道(channel)
- 18.9 網絡和網頁應用
- 18.10 其他
- 18.11 出于性能考慮的最佳實踐和建議
- 附錄