golang復合類型包括：結構體、數組、切片、Maps。
1、數組
數組
golang中的數組與C語言中的數組差異很大，倒更類似Pascal中的數組。 (Slice，下個話題，有些像C語言中的數組)
var ar [3]int
聲明ar為一個擁有三個整型數的數組，所有元素初始化為0。
大小是類型的一個組成部分。
內置的函數len可以用于獲取數組大?。?/p>
len(ar) = 3
數組是值類型
golang中的數組是值，而非C語言中的隱式指針。你可以獲得數組的地址，并生成一個指向數組的指針(例如，將其高效地傳遞給函數)：
func f(a [3]int) { fmt.Println(a) }
func fp(a *[3]int) { fmt.Println(a) }
func main() {
var ar [3] int
f(ar) // 傳遞一個ar的拷貝
fp(&ar) // 傳遞一個指向ar的指針
}
輸出結果：
[0 0 0]
&[0 0 0]
數組字面值
所有的符合類型都有相同的值創建語法。以數組為例，其語法如下：
3個整數的數組：
[3]int{1, 2, 3}
10個整數的數組，前三個元素不是0：
[10]int{ 1, 2, 3}
不想數？使用…代表長度：
[...]int{1, 2, 3}
不想初始化所有值？使用key:value對：
[10]int{2:1, 3:1, 5:1, 7:1}
指向數組字面值的指針
你可以獲取數組字面值的地址，這樣可以得到一個指向新建數組實例的指針：
func fp(a *[3]int) { fmt.Println(a) }
func main() {
for i := 0; i < 3; i++ {
fp(&[3]int{i, i*i, i*i*i})
}
}
輸出結果：
&[0 0 0]
&[1 1 1]
&[2 4 8]
2、切片(Slice)
切片
切片是對數組中某一段的引用。
切片比普通數組應用得更多也更廣泛。
切片使用的代價很低。
一個切片類型很像一個沒有大小的數組類型：
var a []int
內置的len(a)可以返回切片中元素的個數。
通過對數組或切片進行"切片"，我們可以創建一個新切片：
a = ar[7:9]
a(上面例子中的a)的有效下標值是0和1；len(a) == 2。
切片速記
當對數組進行切片時，第一個下標值默認是0：
ar[:n]等價于a[0:n]。
第二個下標值默認為len(array/slice)：
ar[n:]等價于ar[n:len(ar)]。
因此由數組創建切片時：
ar[:]等價于ar[0:len(ar)]。
切片引用數組
概念上：
type Slice struct {
base *elemType // 指向0th元素的指針
len int // 切片中元素的數量
cap int // 切片可以容納元素的數量
}
數組：
ar： 7 1 5 4 3 8 7 2 11 5 3
切片：
a = ar[7:9] ：base = &ar[7](指向ar中的2) len = 2 cap = 4
創建切片
切片字面值看起來像沒有指定大小的數組字面值：
var slice = []int{1,2,3,4,5}
上面代碼創建了一個長度為5的數組并創建一個切片用于引用這個數組。
我們可以使用內置的make函數分配一個切片（底層實際是個數組）：
var s100 = make([]int, 100) // slice: 100 ints
為何用make而不是用new？因為我們需要創建切片，而不僅僅是為了分配內存。注意make([]int, 10)返回[]int，而new([]int)返回*[]int。
使用make創建切片、map以及channel。
切片容量
切片是對底層數組的一個引用。因此存在一些在數組里但卻沒在切片引用的范圍內的元素。
內置的函數cap(capacity)用于報告切片可能增長到多長。
var ar = [10]int{0,1,2,3,4,5,6,7,8,9}
var a = ar[5:7] // 引用子數組{5,6}
len(a) = 2，cap(a) = 5，現在我們可以重新切片：
a = a[0:4] // 引用子數組 {5,6,7,8}
len(a)現在是4，而cap(a)依舊是5。
調整切片大小
切片可被當作可增長的數組用。使用make分配一個切片，并指定其長度和容量。當要增長時，我們可以做重新切片：
var sl = make([]int, 0, 100) // 長度 0, 容量 100
func appendToSlice(i int, sl []int) []int {
if len(sl) == cap(sl) { error(…) }
n := len(sl)
sl = sl[0:n+1] // 長度增加1
sl[n] = i
return sl
}
因此，sl的長度總是元素的個數，但其容量可根據需要增加。
這種手法代價很小，并且是Go語言中的慣用法。
切片使用的代價很小
你可以根據需要自由地分配和調整切片大小。它們的傳遞僅需要很小的代價；不必分配。
記住它們是引用，因此下層的存儲可以被修改。
例如，I/O使用切片，而不是計數：
func Read(fd int, b []byte) int
var buffer [100]byte
for i := 0; i < 100; i++ {
// 每次向Buffer中填充一個字節
Read(fd, buffer[i:i+1]) // no allocation here
}
拆分一個Buffer：
header, data := buf[:n], buf[n:]
字符串也可以被切片，而且效率相似。
3、Maps
maps
Map是另外一種引用類型。它們是這樣聲明的：
var m map[string]float64
這里聲明了一個map，索引key的類型為string，值類型為float64。這類似于C++中的類型*map<string, float64>。
對于給定map m，len(m)返回key的數量。
map的創建
和創建一個切片一樣，一個map變量是一個空引用；在可以使用它之前，應先要向里面放入一些內容。
三種方式：
1) 字面值：逗號分隔的key:value對列表
m = map[string]float64{"1":1, "pi":3.1415}
2) 創建
m = make(map[string]float64) // make not new
3) 賦值
var m1 map[string]float64
m1 = m // m1和m現在引用相同的map
map索引
(接下來的幾個例子全都使用：
m = map[string]float64{"1":1, "pi":3.1415})
訪問一個元素；如果該元素不存在，則得到對應map value類型的零值：
one := m["1"]
zero := m["not present"] // zero被置為0.0.
設置一個元素的值(兩次設置將更新為最新值)
m["2"] = 2
m["2"] = 3 // 思維混亂
測試存在性
要測試一個map中是否存在某個key，我們可以使用一個多項賦值的"comma, om"形式：
m = map[string]float64{"1":1, "pi":3.1415}
var value float64
var present bool
value, present = m[x]
或者按慣例：
value, ok := m[x] // "comma ok" 形式
如果map中存在x這個key，布爾變量會被設置為true；value會被賦值為map中key對應的值。相反，布爾變量會被設置為false，value被設置為相應值類型的零值。
刪除
使用多元賦值可以刪除map中的一個值：
m = map[string]float64{"1":1.0, "pi":3.1415}
var keep bool
var value float64
var x string = f()
m[x] = v, keep
如果keep的值為true，則將v賦值到map中；如果keep為false，則刪除map中的key x。因此刪除一個key：
m[x] = 0, false // 從map中刪除x
譯注：Go 1中上述的刪除方式已被取消，取而代之的是delete(m, x)。
for和range
對于數組、切片和map（以及我們在第三部分將要看到的更多類型），for循環提供了一種特殊的語法用于迭代訪問其中的元素。
m := map[string]float64{"1":1.0, "pi":3.1415}
for key, value := range m {
fmt.Printf("key %s, value %g/n", key, value)
}
只用一個變量，我們可以獲得key：
for key = range m {
fmt.Printf("key %s/n", key)
}
變量可以用:=賦值或聲明。
對于數組和切片來說，通過這種方式我們可以獲得元素的下標以及元素值。
將range用于字符串
將for range用于字符串時，實際迭代的元素是Unicode碼點(code point)，而不是字節（對字節，可使用[]byte或使用標準的for語句）。我們假設字符串包
含使用UTF-8編碼的字符。
下面循環：
s := "[/u00ff/u754c]"
for i, c := range s {
fmt.Printf("%d:%q ", i, c) // %q for 'quoted'
}
輸出：0:'[' 1:'ÿ' 3:'界' 6:']'
如果遇到了錯誤的UTF-8碼點，這個字符將被設置為U+FFFD，下標向后移動一個字節。
4、Structs
structs
對于Go中的struct，你應該感覺十分熟悉：簡單的數據字段聲明。
var p struct {
x, y float64
}
更常用的是：
type Point struct {
x, y float64
}
var p Point
struct允許程序員定義內存布局。
struct是值類型
struct是值類型，new(StructType)返回一個指向零值的指針（分配的內存都被置0）。
type Point struct {
x, y float64
}
var p Point
p.x = 7
p.y = 23.4
var pp *Point = new(Point)
*pp = p
pp.x = Pi // (*pp).x的語法糖
對于結構體指針，沒有->符號可用。Go提供了間接的方式。
創建結構體
結構體是值類型，因此你可只通過聲明就可以創建一個全0的結構體變量。
你也可以使用new創建一個結構體。
var p Point // 零值
pp := new(Point) // 慣用法
結構體字面值語法也不出所料：
p = Point{7.2, 8.4}
p = Point{y:8.4, x:7.2}
pp = &Point{7.2, 8.4} // 慣用法
pp = &Point{} //也是慣用法，== new(Point)
和數組一樣，得到了結構體字面值的地址，就得到了新建結構體的地址。
這些例子都是構造器。
導出類型和字段
只有當結構體的字段(和方法，即將講解)名字的首字母大寫時，它才能被包外可見。
私有類型和字段：
type point struct { x, y float64 }
導出類型和字段：
type Point struct { X, Y float64 }
導出類型和私有類型混合字段：
type Point struct {
X, Y float64 // exported
name string // not exported
}
你甚至可以創建一個帶有導出字段的私有類型。（練習：何時能派上用場呢？）
匿名字段
在一個結構體內，你可以聲明不帶名字的字段，比如另外一個結構體類型。這些字段被稱為匿名字段。它們看起來就像里層的結構體簡單插入或“嵌入”到
外層結構體似的。
這個簡單的機制為從其他類型繼承已有的實現提供了一種方法。
下面是一個例子。
一個匿名結構體字段:
type A struct {
ax, ay int
}
type B struct {
A
bx, by float64
}
B看起來像有四個字段ax、ay、bx和by。B可看成{ax, ay int; bx, by float64}。
然后B的字面值必須提供細節：
b := B{A{1, 2}, 3.0, 4.0}
fmt.Println(b.ax, b.ay, b.bx, b.by)
輸出1 2 3 4
匿名字段以類型作為名字
匿名字段不僅僅是簡單插入這些字段這么簡單，其含義更為豐富：B還擁有字段A。匿名字段看起來就像名字為其類型名的字段。
b := B{A{ 1, 2}, 3.0, 4.0}
fmt.Println(b.A)
輸出：{1 2}。如果A來自于另外一個包，這個字段依舊被稱為A。
import "pkg"
type C struct { pkg.A }
…
c := C {pkg.A{1, 2}}
fmt.Println(c.A) // 不是 c.pkg.A
任意類型的匿名字段
任何具名類型或指向具名類型的指針都可以用作匿名字段。它們可以出現在結構體中的任意位置。
type C struct {
x float64
int
string
}
c := C{3.5, 7, "hello"}
fmt.Println(c.x, c.int, c.string)
輸出：3.5 7 hello
沖突和遮蔽
如果有兩個字段具有相同的名字(可能是一個繼承類型的名字)，代碼將遵循下面規則：
1) 外層的名字遮蔽內層的名字。這提供了一個重寫字段/方法的方式。
2) 如果在同一層次上出現了相同的名字，如果名字被使用，那么將是一個錯誤。(如果沒有使用，不會出現錯誤)
二義性是沒有規則能解決的，必須被修正。
沖突的例子
type A struct { a int }
type B struct { a, b int }
type C struct { A; B }
var c C
使用c.a將會出現錯誤。它到底是c.A.a還是c.B.a呢？
type D struct { B; b float64 }
var d D
使用d.b沒有問題：它是float64類型變量，不是d.B.b。要獲得內層的b，可用d.B.b。
