复合类型

复合类型

类型	名称	长度	默认值	说明
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内的数
    }

}