复合类型

复合类型

类型	名称	长度	默认值	说明
pointer	指针		nil
array	数组		0
slice	切片		nil	引⽤类型
map	字典		nil	引⽤类型
struct	结构体

指针

指针是一个代表着某个内存地址的值。这个内存地址往往是在内存中存储的另一个变量的值的起始位置。

1、指针的基本操作

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、不要操作没有合法指向的内存

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 函数使用

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、普通变量做函数参数

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、随机种子

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内的数
	}

}