复合类型
| 类型 | 名称 | 长度 | 默认值 | 说明 |
|---|---|---|---|---|
| pointer | 指针 | nil | ||
| array | 数组 | 0 | ||
| slice | 切片 | nil | 引⽤类型 | |
| map | 字典 | nil | 引⽤类型 | |
| struct | 结构体 |
指针
指针是一个代表着某个内存地址的值。这个内存地址往往是在内存中存储的另一个变量的值的起始位置。
1、指针的基本操作
```import "fmt"
func main() {
var a int = 10
//每个变量有2层含义：变量的内存，变量的地址
fmt.Printf("a = %d\n", a) //变量的内存
fmt.Printf("&a = %v\n", &a)
}
## 2、指针
+ 保存某个变量的地址，需要指针类型 *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)}
```
3、不要操作没有合法指向的内存
```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)}
```
4、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)}
```
5、普通变量做函数参数
```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)}
## 6、指针做函数
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)}
# 数组
## 1、概念
数组是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（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
```
2、数组的基本操作
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)
}
}3、数据的初始化
import "fmt"
func main() {
//声明定义同时赋值，叫初始化
//1、全部初始化
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)
}
4、二维数组
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)
}5、数组比较和赋值
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)
}6、随机种子
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内的数
}
}