複合類型

複合類型

類型	名稱	長度	默認值	說明
pointer	指針		nil
array	數組		0
slice	切片		nil	引⽤類型
map	字典		nil	引⽤類型
struct	結構體

指針

指針是一個表明着某個內存地址的值。這個內存地址每每是在內存中存儲的另外一個變量的值的起始位置。

一、指針的基本操做

```import "fmt"

func main() {
var a int = 10
//每一個變量有2層含義：變量的內存，變量的地址
fmt.Printf("a = %d\n", a) //變量的內存
fmt.Printf("&a = %v\n", &a)
}

![1538962111533](C:\Users\zhang\AppData\Roaming\Typora\typora-user-images\1538962111533.png)



## 二、指針

+ 保存某個變量的地址，須要指針類型   *int 保存int的地址， **int 保存 *int 地址

+ 聲明(定義)， 定義只是特殊的聲明，定義一個變量p, 類型爲*int   例如： var p *int

+ 指針變量指向誰，就把誰的地址賦值給指針變量   例如：p = &a

package main //必須有個main包

import "fmt"

func main() {
var a int = 10
//每一個變量有2層含義：變量的內存，變量的地址
fmt.Printf("a = %d\n", a) //變量的內存
fmt.Printf("&a = %v\n", &a)

//保存某個變量的地址，須要指針類型   *int 保存int的地址， **int 保存 *int 地址
//聲明(定義)， 定義只是特殊的聲明
//定義一個變量p, 類型爲*int
var p *int
p = &a //指針變量指向誰，就把誰的地址賦值給指針變量
fmt.Printf("p = %v, &a = %v\n", p, &a)

*p = 666 //*p操做的不是p的內存，是p所指向的內存(就是a)
fmt.Printf("*p = %v, a = %v\n", *p, a)

}
```

三、不要操做沒有合法指向的內存

```import "fmt"

func main() {
var p *int
p = nil
fmt.Println("p = ", p)

//*p = 666 //err, 由於p沒有合法指向

var a int
p = &a //p指向a
*p = 666
fmt.Println("a = ", a)

}
```

四、new 函數使用

```import "fmt"

func main() {
//a := 10 //整型變量a

var p *int
//指向一個合法內存
//p = &a

//p是*int, 指向int類型
p = new(int)

*p = 666
fmt.Println("*p = ", *p)

q := new(int) //自動推導類型
*q = 777
fmt.Println("*q = ", *q)

}
```

五、普通變量作函數參數

```import "fmt"

func swap(a, b int) {
a, b = b, a
fmt.Printf("swap: a = %d, b = %d\n", a, b)
}

func main() {
a, b := 10, 20

//經過一個函數交換a和b的內容
swap(a, b) //變量自己傳遞，值傳遞（站在變量角度）
fmt.Printf("main: a = %d, b = %d\n", a, b)

}

![1538963893111](C:\Users\zhang\AppData\Roaming\Typora\typora-user-images\1538963893111.png)



## 六、指針作函數

package main //必須有個main包

import "fmt"

func swap(p1, p2 int) {
p1, p2 = p2, *p1
}

func main() {
a, b := 10, 20

//經過一個函數交換a和b的內容
swap(&a, &b) //地址傳遞
fmt.Printf("main: a = %d, b = %d\n", a, b)

}

![1538965860574](C:\Users\zhang\AppData\Roaming\Typora\typora-user-images\1538965860574.png)



# 數組

## 一、概念

數組是指一系列同一類型數據的集合。數組中包含的每一個數據被稱爲數組元素（element），一個數組包含的元素個數被稱爲數組的長度。

func main() {
// id1 := 1
// id2 := 2
// id3 := 3

//數組，同一個類型的集合
var id [50]int

//操做數組，經過下標， 從0開始，到len()-1
for i := 0; i < len(id); i++ {
    id[i] = i + 1
    fmt.Printf("id[%d] = %d\n", i, id[i])
}

}

**數組⻓度必須是常量**，且是類型的組成部分。 [2]int 和 [3]int 是不一樣類型。

var n int = 10

var a [n]int //err, non-constant array bound n

var b [10]int //ok
```

二、數組的基本操做

import "fmt"

func main() {
    //定義一個數組, [10]int和[5]int是不一樣類型
    //[數字]， 這個數字做爲數組元素個數
    var a [10]int
    var b [5]int

    fmt.Printf("len(a) = %d, len(b) = %d\n", len(a), len(b))

    //注意：定義數組是，指定的數組元素個數必須是常量
    //n := 10
    //var c [n]int //err non-constant array bound n

    //操做數組元素，從0開始，到len()-1, 不對稱元素，這個數字，叫下標
    //這是下標，能夠是變量或常量
    a[0] = 1
    i := 1
    a[i] = 2 // a[1] = 2

    //賦值，每一個元素
    for i := 0; i < len(a); i++ {
        a[i] = i + 1
    }

    //打印
    //第一個返回下標，第二個返回元素
    for i, data := range a {
        fmt.Printf("a[%d] = %d\n", i, data)
    }

}

三、數據的初始化

import "fmt"

func main() {
    //聲明定義同時賦值，叫初始化
    //一、所有初始化
    var a [5]int = [5]int{1, 2, 3, 4, 5}
    fmt.Println("a = ", a)

    b := [5]int{1, 2, 3, 4, 5}
    fmt.Println("b = ", b)

    //部分初始化，沒有初始化的元素，自動賦值爲0
    c := [5]int{1, 2, 3}
    fmt.Println("c = ", c)

    //指定某個元素初始化
    d := [5]int{2: 10, 4: 20}
    fmt.Println("d = ", d)

}

四、二維數組

import "fmt"

func main() {
    //有多少個[]就是多少維
    //有多少個[]就用多少個循環
    var a [3][4]int

    k := 0
    for i := 0; i < 3; i++ {
        for j := 0; j < 4; j++ {
            k++
            a[i][j] = k
            fmt.Printf("a[%d][%d] = %d, ", i, j, a[i][j])
        }
        fmt.Printf("\n")
    }

    fmt.Println("a = ", a)

    //有3個元素，每一個元素又是一維數組[4]int
    b := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
    fmt.Println("b = ", b)

    //部分初始化，沒有初始化的值爲0
    c := [3][4]int{{1, 2, 3}, {5, 6, 7, 8}, {9, 10}}
    fmt.Println("c = ", c)

    d := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}
    fmt.Println("d = ", d)

    e := [3][4]int{1: {5, 6, 7, 8}}
    fmt.Println("e = ", e)
}

五、數組比較和賦值

import "fmt"

func main() {
    //支持比較，只支持 == 或 !=, 比較是否是每個元素都同樣，2個數組比較，數組類型要同樣
    a := [5]int{1, 2, 3, 4, 5}
    b := [5]int{1, 2, 3, 4, 5}
    c := [5]int{1, 2, 3}
    fmt.Println(" a == b ", a == b)
    fmt.Println(" a == c ", a == c)

    //同類型的數組能夠賦值
    var d [5]int
    d = a
    fmt.Println("d = ", d)
}

六、隨機種子

https://studygolang.com/

package main //必須有個main包

import "fmt"
import "math/rand"
import "time"

func main() {
    //設置種子， 只需一次
    //若是種子參數同樣，每次運行程序產生的隨機數都同樣
    rand.Seed(time.Now().UnixNano()) //以當前系統時間做爲種子參數

    for i := 0; i < 5; i++ {

        //產生隨機數
        //fmt.Println("rand = ", rand.Int()) //隨機很大的數
        fmt.Println("rand = ", rand.Intn(100)) //限制在100內的數
    }

}