03---复合数据类型的操作

柔情只为你懂 2022-11-15 11:22 219阅读 0赞

### GO复合数据类型 ###

*   *  一：数组：
     *   *  1.1：数组的定义, 打印输出：
         *  1.2：数组查询元素：
         *  1.3：数组初始化与初始化赋值：
         *  1.4：遍历数组：
         *  1.5：数组中常见的危险操作：
         *  1.6：二维数组：
         *  1.7：随机数：
     *  二：切片：
     *   *  2.1： 切片的定义赋值与遍历：
         *  2.2：切片如何追加元素：
         *  2.3：定义切片指定长度
         *  2.4：自动推导类型定义切片：
         *  2.5:切片的地址与扩容：
         *  2.6:切片的截取：
         *  2.7：切片的拷贝：
         *  2.8：切片进行排序：
         *  2.9：函数参数中携带数组, 与携带切片的区别：
     *  三：map（字典）
     *   *  3.1：字典的定义：
     *  四：结构体：
     *   *  4.1：结构体的定义和使用：
         *  4.2：结构体的赋值和比较：
         *  4.3：结构体数组和结构体切片：
         *  4.4： 结构体作为map的值：
         *  4.5：结构体作为函数参数：
         *  4.6：结构体实际开发案例：
     *  五：指针：
     *   *  5.1： 指针的内存存储模型：
         *  5.2：指针的定义和基本使用：
         *  5.3：指针变量作为函数参数：
         *  5.4： 数组指针：
         *  5.5：指针数组：
         *  5.6: 切片指针
         *  5.7：结构体指针
         *  5.8：多级指针：
     *  六：内存模型：

## 一：数组： ##

### 1.1：数组的定义, 打印输出： ###

*  数组的定义格式： var 数组名 \[元素的个数\] 元素的类型
 *  数组如果是int 类型，则初始化数组默认是0.
    
        // 1:数组的定义： var 数组名 [元素个数] 元素类型， int默认是0
        	var arr [10] int

### 1.2：数组查询元素： ###

*  通过下标寻找某个元素：
    
        // 2: 通过下标寻找某个元素
        	arr[0] = 10 // 元素赋值
        	fmt.Println(arr[0]) // 获取第一个元素 10

### 1.3：数组初始化与初始化赋值： ###

*  数组的初始化赋值：
 *  如果数量少于初始化个数，则后面默认补零。
 *      // 4：数组初始化赋值：如果赋值少了，后面自动补0，如果超了则报错var arr2 = [10] int {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
 *  还可以指定下标进行赋值：
    
        // 指定下标赋值：var arr3 = [10] int {1:10, 4:20, 6:30}fmt.Println(arr3)

### 1.4：遍历数组： ###

*  使用for循环遍历：
    
        // 5： 遍历数组：
        	for i:= 0; i < len(arr); i++ {
              
        		fmt.Println(arr2[i])
        	}
 *  使用range函数进行遍历：
    
        // 或者使用range
        	for _, v:= range arr{
              
        		fmt.Println(v)
        	}

### 1.5：数组中常见的危险操作： ###

*  1： go中的数组是不允许出现负数下标的：
    
        arr[-1] 是不允许的。
 *  2：数组类型的变量不能重新赋值成一个变量类型：
    
        // 7： 数组类型的变量不能重新赋值成一个变量（经常出错的）， 两个数组如果类型+元素个数都相同才可以赋值。
 *  3：数组中不允许使用变量
    
        // 8：数组不允许使用变量，例如：
        	// i := 10
        	// var arr [i] int = [10] int {1, 2, 3, 4, 5},, 错误的。
        	const i  = 10
        	var arr4 [i] int = [10] int {
              1, 2}
        	fmt.Println(arr4)
 *  4: 数组地址就是数组中首位元素的地址，其余地址等于上个地址 + 8
    
        // 9： 打印数组的地址，与数组中元素地址：
            fmt.Printf("数组地址： %p\n", &arr4)
        	fmt.Printf("数组中元素地址：%p\n", &arr4[0])
        	fmt.Printf("数组中元素地址：%p\n", &arr4[1])
            // 通过打印地址发现：数组的地址跟头号元素的地址是相同的。
            // 下一个元素的地址等于上一个元素的地址+8

### 1.6：二维数组： ###

*  二维数组的定义：
    
    案例：
    
        // 1:定义一个二维数组
        	var arr[2][3] int
        
        	// 2: 求二维数组的行,与列
        	n := len(arr)
        	m := len(arr[0])
        	fmt.Println(n)
        	fmt.Println(m)
        
        	// 3: 给二维数组赋值：
        	arr [0][0] = 111
        	fmt.Println(arr)
        
        	// 4: 二维数组的遍历
        	for i := 0; i < len(arr); i++ {
              
        		for j := 0; j < len(arr[0]); j++{
              
        			fmt.Println(arr[i][j])
        		}
        	}
        	// 也可以使用range进行遍历
        	for _, v := range arr{
              
        		for _ ,x := range v{
              
        			fmt.Println(x)
        		}
        	}

### 1.7：随机数： ###

*  随机数导包： math/rand
 *  制作随机数种子：
 *  创建随机数：

案例： 产生10以内的一个随机数：

func main() {
        
    	// 创建随机数种子， 进行数据的混淆,使用当前值的纳秒值进行混淆
    	// 如果不加随机数种子，则是默认是1970/1/1日进行混淆的。
    	rand.Seed(time.Now().UnixNano())
    	// 随机产生10以内的数据：
    	fmt.Println(rand.Intn(10))
    }

## 二：切片： ##

### 2.1： 切片的定义赋值与遍历： ###

// 1:var 切片名 [] 数据类型
    	var slice []int = []int {
        1, 2, 3, 4, 5}
    	fmt.Println(slice)
    	// 2: 切片的赋值
    	slice[0] = 124
    	fmt.Println(slice)
    	// 3: 遍历切片
    	for i,v := range slice{
        
    		fmt.Println(i, v)
    	}

### 2.2：切片如何追加元素： ###

// 4: 切片增加元素需要使用函数，而不能直接添加，append（函数名，值），会返回一个新的对象。
    	slice = append(slice,456, 7, 8 )
    	// 注意使用 slice[10] = 20 是错误的。

### 2.3：定义切片指定长度 ###

// 5: 在定义切片时可以指定长度
    	var slice2 [] int = make([] int, 10)
    	fmt.Println(len(slice2))
    	// 可以使用 = 赋值了
    	slice2[0] = 123
    	fmt.Println(slice2)

### 2.4：自动推导类型定义切片： ###

// 6:自动推导类型定义切片：
    	slice3 := [] int {
        1, 2, 3}
    	fmt.Println(slice3)

### 2.5:切片的地址与扩容： ###

*  了解地址与扩容机制：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70]

*  为什么追加的时候可能会地址改变也可能不会改变？
    
    答： 因为追加的时候，如果没有超过内存碎片的地址，则不会发生内存地址的改变。但是当内存碎片不够（追加 + 原来）总和的时候，系统会重新寻找一块内存地址，将所有数据复制过去，所以内存地址就会发生改变。
 *  定义可扩容切片的两种方式：
    
     *  注意：第一种方式20表示容量， 10表示长度。
     *  指定容量后再次使用append进行追加数据的时候不会修改内存的地址。（当不会超过最大容量的时候）
     *  当使用append超过最大容量了，此时仍然可能会发生改变，则可能不改变，当内存地址后面还有空间则仍不改变。
    
        // slice := make([] int, 10, 20)
        // var slice []int = make([] int , 10)
    
     *  使用cap函数，计算切片的容量：
        
            // 使用cap函数，计算切片的容量：
            	num := cap(slice)
 *  go语言的内存扩容机制是怎样的呢?
    
     *  答： 一般扩容是上一次容量的一倍， 如果超过1024字节，则每次扩容上一次的1/4大小。
     *  注意容量扩容，每次都是偶数。

### 2.6:切片的截取： ###

*  格式： 切片名\[起始地址： 结束位置：最大地址\]
 *  长度 ： 结束地址 - 其实地址
 *  计算容量： 最大地址 - 其实地址
 *  截取后的数据地址，本质还是原来切片中的地址，如果改变切片后的数据，则原有地址对应的数据也发生改变。
    
    案例:
    
        slice := []int {
              1,2,3, 4, 5, 6, 7, 8, 9}
            // 切片名[起始地址： 结束位置：最大地址]
            s:= slice[3:7]
            fmt.Println(s)
            // 计算容量： 最大地址 - 其实地址
            // 长度 ： 结束地址 - 其实地址
            fmt.Println(len(s)) // 4
            fmt.Println(cap(s)) // 5
        	// 截取前5个数据
        	fmt.Println(slice[:5])
            // 注意： 截取后的数据地址，本质还是原来切片中的地址，如果改变切片后的数据，则原有地址对应的数据也发生改变。
            slice2 := [] int {
              0, 1, 2, 3, 4, 5 }
            s2 := slice2[0: 3]
            s2[0] = 1000
            fmt.Println(slice2) // 我们发现原有地址也发生了改变：[1000 1 2 3 4 5]

### 2.7：切片的拷贝： ###

*  需求： 切片是在原来内容进行改变，如果我不想影响之前的内容怎么做？
    
        var slice [] int = [] int {
              1, 2, 3, 4, 5}
        	s := make([]int , 5)
        	// copy格式：copy（新对象， 源对象）
        	copy(s, slice)
        	fmt.Println(s)
        	// 修改s， 看看slice改变了吗？
        	s[0] = 1000
        	fmt.Println(s)
        	fmt.Println(slice) // 没有改变

### 2.8：切片进行排序： ###

*  数据的排序：
    
    案例：
    
        func main(){
              
        	var slice [] int = [] int {
              9, 1, 3, 7, 2, 4}
        	sort.Ints(slice)
        	fmt.Print(slice) // [1 2 3 4 7 9]
        }

### 2.9：函数参数中携带数组, 与携带切片的区别： ###

*  （传递数组）值传递，而不是引用传递：
    
        func BubbleSort(arr [10] int){
              
        	fmt.Println(arr) // [9 1 2 5 2 1 6 7 9 6]
        	arr[0] = 1000
        	fmt.Println(arr)// [1000 1 2 5 2 1 6 7 9 6]
        }
        
        
        func main(){
              
        	arr := [10] int {
              9, 1, 2, 5, 2, 1, 6, 7, 9, 6}
        	BubbleSort(arr)
        	// 注意此时打印的仍然是初始的，而不是被修改后的。
        	fmt.Println(arr)// [9 1 2 5 2 1 6 7 9 6]
        }
 *  （传递数组）如果需要修改主函数的值，需要提供返回值：
    
        func BubbleSort(arr [10] int) [10] int{
              
        	fmt.Println(arr) // [9 1 2 5 2 1 6 7 9 6]
        	arr[0] = 1000
        	fmt.Println(arr)// [1000 1 2 5 2 1 6 7 9 6]
        	return arr
        }
        
        
        func main(){
              
        	arr := [10] int {
              9, 1, 2, 5, 2, 1, 6, 7, 9, 6}
        	arr = BubbleSort(arr)
        	// 此时arr被修改了
        	fmt.Println(arr) // [1000 1 2 5 2 1 6 7 9 6]
        }
 *  （切片）作为函数参数：
    
     *  与数组不同，切片是引用传递。
        
        案例：
        
            func test(s [] int){
                    
            	fmt.Printf("从函数切片地址：%p\n",s)
            }
            
            
            func main(){
                    
            	slice := [] int {
                    9, 2, 1, 4, 5, 3 ,6, 7, 8, 0}
            	fmt.Printf("主函数切片地址：%p\n",slice)
            	test(slice)
            }
            // 运行结果：
            //主函数切片地址：0xc0000180f0
            //从函数切片地址：0xc0000180f0
    
    案例二：
    
        func test(s [] int){
              
        	sort.Ints(s)
        	fmt.Printf("从函数切片地址：%p\n",s)
        }
        
        
        func main(){
              
        	slice := [] int {
              9, 2, 1, 4, 5, 3 ,6, 7, 8, 0}
        	fmt.Printf("主函数切片地址：%p\n",slice)
        	// 打印slice
        	fmt.Println(slice) // [9 2 1 4 5 3 6 7 8 0]
        	test(slice)
        	// 再次打印slice
        	fmt.Println(slice) // [0 1 2 3 4 5 6 7 8 9]
        }
 *  注意： 如果在函数中使用了，append,则可能会修改内存指向，此时便不会修改原来的地址了。
    
        func test(s [] int){
              
        	fmt.Printf("传入进来的切片的地址：%p\n", s)
        	// 对这个切片进行追加信息
        	s = append(s, 11, 12, 13, 14)
        	fmt.Printf("追加地址后切片的地址：%p\n", s)
        }
        
        
        func main(){
              
        
        	arr := [] int {
              1, 3, 4, 6, 2, 5, 7, 9, 8, 0}
        	fmt.Printf("没有调用之前的切片的地址：%p\n", arr)
        	test(arr)
        	fmt.Printf("没有调用之后的切片的地址：%p\n", arr)
        }
        
        //运行结果：
        //没有调用之前的切片的地址：0xc0000180f0
        //传入进来的切片的地址：0xc0000180f0
        //追加地址后切片的地址：0xc0000100a0
        //没有调用之后的切片的地址：0xc0000180f0

## 三：map（字典） ##

### 3.1：字典的定义： ###

package main
    
    import "fmt"
    
    func main() {
        
    	// 1：map分配空间式定义，初始化空间=1
    	m := make(map[int]string, 1)
    
    	// 2: map具备自动扩容机制，能够自己扩容
    	m[1] = "张三"
    	m[22] = "李四"
    	m[444] = "王五"
    	fmt.Println(m) //map[1:张三 22:李四 444:王五]
    
    	// 3:map中的键值对是没有顺序的，因此不能使用使用下标访问。
    
    	// 4: 如何遍历map? ---使用range
    	for k, v := range m {
        
    		fmt.Println(k, v)
    	} // 注意每次结果不一定结果相同。
    	// 1 张三
    	//22 李四
    	//444 王五
    
    	// 5： map中的key不允许重复
    
    	// 6：打印字典的值
    	fmt.Println(m[1]) //张三
    	// 如果打印的key不存在，则返回空
    	fmt.Println("---", m[3], "----") // ---  ----
    
    	// 7:注意使用ok判断是否是空值，如果不存在可以输出不存在
    	v, ok := m[0]
    	if ok {
        
    		fmt.Println("v的值是：", v)
    	} else {
        
    		fmt.Println("key不存在")
    	}
    
    	// 8: 删除map中的元素
    	mm := map[int]string{
        1: "刘备", 2: "关羽", 3: "张飞"}
    	fmt.Println(mm) // map[1:刘备 2:关羽 3:张飞]
    	// delete删除整个键值对, 如果这个键不存在也不会报错
    	delete(mm, 1)
    	fmt.Println(mm) //map[2:关羽 3:张飞]
    
    	// 9: map作为函数参数---引用传递,在函数中，进行增加，修改，删除，操作都会影响主调函数的值。
    	demo(mm)
    	fmt.Println(mm) // map[2:孙悟空 3:张飞 4:美猴王]
    
    }
    
    func demo(m map[int]string) {
        
    	// 修改数据
    	m[2] = "孙悟空"
    	fmt.Println(m) // map[2:孙悟空 3:张飞]
    	// 增加数据
    	m[4] = "美猴王"
    	fmt.Println(m) // map[2:孙悟空 3:张飞 4:美猴王]
    }

## 四：结构体： ##

### 4.1：结构体的定义和使用： ###

package main
    
    import "fmt"
    
    // 1: 在函数外部定义结构体 ---作用域是全局的，可以在其他的目录中使用
    type Student struct {
        
    	id   int
    	name string
    	age  int
    	sex  int
    }
    
    func main() {
        
    
    	// 2: 通过结构体名创建结构体变量: var 结构体变量名 结构体名
    	var stu Student
    	// 3：结构体内元素进行赋值: 结构体变量名.成员名
    	stu.id = 111
    	stu.name = "一夜奈何梁山"
    	stu.age = 39
    	stu.sex = 0
    
    	// 4:打印结构体变量，看看值是怎样的
    	fmt.Println(stu) // {111 一夜奈何梁山 39 0}
    
    	// 5: 打印一下结构体变量的类型
    	fmt.Printf("结构体变量的类型是： %T\n", stu) // 结构体变量的类型是： main.Student
    
    	// 6:结构体变量定义的第二种方式：
    	var s Student = Student{
        111, "一夜奈何梁山", 39, 0}
    	fmt.Println("id是：", s.id)
    	fmt.Println("名字是：", s.name)
    
    	// 7: 使用自动推导类型
    	ss := Student{
        age: 30, id: 103, name: "黑匣子", sex: 0}
    	fmt.Println(ss) // {103 黑匣子 30 0}
    }

### 4.2：结构体的赋值和比较： ###

package main
    
    import "fmt"
    
    type Students struct {
        
    	id   int
    	name string
    	sex  int
    	age  int
    	addr string
    }
    
    func main() {
        
    	s := Students{
        101, "一夜奈何梁山", 18, 22, "徐州"}
    	s.age = 33
    	fmt.Println(s) // {101 一夜奈何梁山 18 33 徐州}
    	// 1:结构体的赋值不会影响原来的
    	s1 := s
    	s1.age = 44
    	fmt.Println(s)  // {101 一夜奈何梁山 18 33 徐州}
    	fmt.Println(s1) // {101 一夜奈何梁山 18 44 徐州}
    
    	// 2: 使用== 判断两个结构体的值是否相同, 但是结构体不允许使用大于小于进行比较操作。只能使用等于或者不等于
    	s2 := s
    	if s2 == s {
        
    		fmt.Println("相同") // 相同
    	} else {
        
    		fmt.Println("不相同")
    	}
    
    	// 3: 但是对于结构体成员之间可以使用大于小于进行比较。
    	if s1.age >= s2.age {
        
    		fmt.Println("大于小于对于结构体成员可以比较")
    	}
    }

### 4.3：结构体数组和结构体切片： ###

*  结构体数组：
    
        package main
        
        import "fmt"
        
        type Teacher struct {
              
        	id   int
        	name string
        	age  int
        	sex  int
        }
        
        func main() {
              
        	// 1：定义结构体数组变量定义
        	var arr [5]Teacher
        	// 2: 计算结构体数组个数
        	fmt.Println("结构体数组元素个数：", len(arr))
        	// 3: 对结构体数组进行赋值
        	arr[0].age = 23
        	arr[0].name = "一夜奈何梁山"
        	arr[0].sex = 0
        	arr[0].id = 111
        	// 4:打印结构体数组
        	fmt.Println(arr) // [{111 一夜奈何梁山 23 0} {0  0 0} {0  0 0} {0  0 0} {0  0 0}]
        	// 5: 定义结构体数组，并进行赋值操作
        	arr2 := [2]Teacher{
              
        		{
              111, "曹操", 23, 0},
        		{
              112, "貂蝉", 18, 1}, // 注意: 最后这个逗号不能省略，或者将大括号放在后面
        	}
        	fmt.Println(arr2) // [{111 曹操 23 0} {112 貂蝉 18 1}]
        }
 *  结构体切片：
    
     *  1：区别在于结构体切片可以使用append增加结构体。
     *  案例：
        
            package main
            
            import "fmt"
            
            type Teacher_and_Student struct {
                    
            	id   int
            	name string
            	age  int
            }
            
            func main() {
                    
            	// 1: 定义结构体切片
            	var arr []Teacher_and_Student
            	// 2: 向结构体切片中增加元素
            	arr = append(arr, Teacher_and_Student{
                    100, "刘备", 23})
            	// 3: 打印结构体切片
            	fmt.Println(arr) // [{100 刘备 23}]
            }

### 4.4： 结构体作为map的值： ###

### 4.5：结构体作为函数参数： ###

*  传递： 值传递
 *  代码展示：
    
        package main
        
        import "fmt"
        
        // 定义结构体
        type Person struct {
              
        	id    int
        	name  string
        	score int
        	sex   string
        }
        
        // 定义函数
        func test01(p Person) {
              
        	// 内部修改结构体内容
        	p.name = "徐来"
        	// 打印p的信息
        	fmt.Println("函数内部结构体变量的值：", p) // 函数内部结构体变量的值： {101 徐来 9 男}
        }
        
        func main() {
              
        	// 定义结构体变量
        	stu := Person{
              101, "清风", 9, "男"}
        	// 将结构体变量作为函数参数传递----值传递还是引用传递？
        	test01(stu)
        	// 打印主调函数中结构体的值
        	fmt.Println("主调函数结构体的值是：", stu) // 主调函数结构体的值是： {101 清风 9 男}
        	// 由此可以判断，结构体作为函数参数是值传递，而不是引用传递。
        }
 *  结构体切片作为函数的参数
    
     *  结构体切片传递的是地址传递。
     *  代码案例：
        
            package main
            
            import "fmt"
            
            // 定义结构体
            type Person struct {
                    
            	id    int
            	name  string
            	score int
            	sex   string
            }
            
            /*
            对于结构体切片来说，函数传递是引用传递，但是当传递过去后使用append后将改变内存的地址。
            */
            
            func test01(stus []Person) {
                    
            	// 给结构体切片替换数据
            	stus[0].name = "两夜"
            	// 给结构题切片中追加数据
            	stus = append(stus, Person{
                    103, "爸爸", 500, "女"})
            	// 打印函数内的结构体切片
            	fmt.Println("函数内的结构体数组：", stus) // 函数内的结构体数组： [{100 两夜 200 男} {101 奈何 300 女} {102 梁山 400 男} {103 爸爸 500 女}]
            }
            
            func main() {
                    
            	// 1: 定义结构体切片
            	stus := []Person{
                    {
                    100, "一夜", 200, "男"}, {
                    101, "奈何", 300, "女"}}
            	// 2: 给结构体切片追加数据
            	stus = append(stus, Person{
                    102, "梁山", 400, "男"})
            	// 3: 调用函数， 传递结构体切片
            	test01(stus)
            	// 打印主调函数中的结构体切片
            	fmt.Println("主调函数中的结构体数组是：", stus) // 主调函数中的结构体数组是： [{100 两夜 200 男} {101 奈何 300 女} {102 梁山 400 男}]
            }

### 4.6：结构体实际开发案例： ###

## 五：指针： ##

### 5.1： 指针的内存存储模型： ###

*  1： 对于一个整型变量，我们一般存储在栈区， 假设现在定义了一个变量a, 值是50, 地址是228f77b0。
 *  2：现在定义一个指针类型的变量p， 这个变量存储a变量的地址。
 *  3：所以现在打印p,得到的是a的地址，而打印p的地址，还是得到p的地址。

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xQ3nExC3-1618990977191)(C:\\Users\\11737\\AppData\\Roaming\\Typora\\typora-user-images\\1618745275623.png)\]][img-xQ3nExC3-1618990977191_C_Users_11737_AppData_Roaming_Typora_typora-user-images_1618745275623.png]

### 5.2：指针的定义和基本使用： ###

*  指针的定义：var 指针名 \*变量的类型
 *  指针的定义和赋值： var 指针名 \*变量的类型 = &变量名
 *  指针的作用 ： 保存变量地址
 *  代码：
    
        package main
        
        import "fmt"
        
        func main(){
              
        	// 1: 定义一个变量
        	a := 10
        
        	// 2: 定义一个指针，指向a的内存地址
        	var p *int = &a
        	fmt.Printf("p指针的值是：%p\n", p) // p指针的值是：0xc00000a0a8
        	fmt.Printf("a的内存地址是：%p\n", &a) // a的内存地址是：0xc00000a0a8
        	fmt.Printf("p的内存地址是：%p\n", &p) // p的内存地址是：0xc000006028
        
        	// 3: 使用指针修改变量的值
        	*p = 123
        	fmt.Printf("修改p指针所对应的是，则a变成：%d\n", a) // 修改p指针所对应的是，则a变成：123
        
        	// 4: 定义一个字符串类型的指针
        	var name string = "一夜奈何梁山"
        	var p1 *string = &name
        	fmt.Printf("p1对应的变量的地址是：%p\n", p1) // p1对应的变量的地址是：0xc000042240
        
        	// 5: 如果只定义指针，而不进行赋值，则指针变量默认指向0x0
        	var p2 *int
        	fmt.Printf("默认条件下指针指向：%p\n", p2) // 默认条件下指针指向: 0x0
        
        	// 6:注意事项： 如果定义了一个指针，没有赋值，然后对这个指针指向的地址进行赋值，会导致赋值失败
        	// 注意：0到255的空间是系统占用的，会导致异常
        	var p3 *int
        	// *p3 = 123 // panic: runtime error: invalid memory address or nil pointer dereference
        	// 应该如何操作？
        	p3 = new(int) // new（）可以开辟对应的数据类型的内存空间，返回对应数据类型的指针
        	*p3 = 123
        	fmt.Printf("p3保存的地址是：%d\n", p3) // p3的值是：824633762000
        
        	// 可以直接赋值一个地址吗？答：不可以
        	// var p *int = *int(824633762000)
        
        	// 了解GO的垃圾回收机制
        	// 我们使用new函数创建一块内存空间给这个指针变量，
        	// 然后当这个指针变量再去指向其他地址的时候，以前的内存如何释放？
        	// 答：GO底层已经封装好了，当引用计数=0的时候，空间就释放掉。
        
        
        	// 7: 通过自动推导类型创建一个指针变量
        	name33 := "一夜奈何梁山"
        	p33 := &name33
        	fmt.Printf("name33的类型是：%T\n", p33) // name33的类型是：*string
        
        }

### 5.3：指针变量作为函数参数： ###

package main
    
    import "fmt"
    
    func swap( a int, b int){
        
    	a, b = b, a //  值进行交换
    }
    
    
    func swap2(a *int, b *int){
        
    	*a, *b = *b, *a // 值进行交换
    }
    
    func main(){
        
    	a , b := 10, 20
    	// 赋值传递
    	swap(a, b)
    	fmt.Printf("赋值传递后的结果：a: %d , b: %d\n", a, b) // 赋值传递后的结果：a: 10 , b: 20
    
    	// 指针传递或者地址传递
    	swap2(&a, &b)
    	fmt.Printf("指针传递后的结果：a: %d , b: %d\n", a, b) // 指针传递后的结果：a: 20 , b: 10
    }

### 5.4： 数组指针： ###

package main
    
    import "fmt"
    
    
    func main(){
        
    
    	//1: 自动推导创建数组指针
    	arr := [10]int{
        1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    	p := &arr
    	fmt.Printf("数组指针的类型： %T\n", p) // 数组指针的类型： *[10]int
    
    	// 2: 手动创建数组指针
    	var p2 *[10]int
    	p2 = &arr
    	fmt.Printf("数组指针的类型： %T\n", p2) // 数组指针的类型： *[10]int
    
    	// 3: 使用数组指针遍历数组
    	for i := 0; i < len(*p); i++{
        
    		fmt.Println(arr[i])
    	}
    
    	// 4: 修改数组的值
    	// 注意： 如果使用指针，因为*的优先级高，因此需要加上括号才可以
    	(*p)[1] = 222
    	fmt.Println(*p) // [1 222 3 4 5 6 7 8 9 10]
    	// 在GO语言中，可以使用指针加[]的方式访问数组中的元素
    	p[0] = 111
    	fmt.Println(*p) // [111 222 3 4 5 6 7 8 9 10]
    
    	// 那么在GO语言中，我们就可以使用指针加下标的方式进行遍历访问
    	for i := 0; i < len(p); i++ {
        
    		fmt.Print(p[i]) // 这两个效果是一样的。
    		fmt.Print((*p)[i])
    	}
    
    	// 5: 指针变量要和数据存储的类型相同：
    	arr2 := [5] int{
        1, 2, 3, 4, 5}
    	var p1 *[5]int = &arr2
    	var p3  *int = &arr2[0]
    	fmt.Println(*p1) // [1 2 3 4 5]
    	fmt.Println(*p3) // 1
    
    
    	// 6：数组指针作为函数参数
    	arr4 := [5] int{
        1,2,3, 4, 5}
    	p55 := &arr4
    	test2(p55)
    	fmt.Println(arr4) // [1 2 123 4 5]
    
    }
    func test2(p *[5] int){
        
    	p[2] = 123
    }

### 5.5：指针数组： ###

package main
    
    import "fmt"
    
    func main(){
        
    	// 1: 定义指针数组
    	var arr [10]*int // 指针数组
    	// var p *[10]int // 数组指针（从后向前读）
    	a := 10
    	b := 20
    	c := 30
    	arr[0] = &a
    	// 2:  定义指针数组，并进行初始化赋值
    	var arr2 [3]*int = [3]*int{
        &a, &b, &c}
    	fmt.Println(arr2) // [0xc00000a0a8 0xc00000a0c0 0xc00000a0c8]
    
    	// 2:修改值如何操作？
    	*arr[0] = 100
    	fmt.Println(a) // 100
    
    	// 3： 打印指针数组对应的地址的值
    	for i := 0; i < len(arr2); i++{
        
    		fmt.Println(*arr2[i])
    	}
    
    	// 4: 数组指针作为指针数组的类型
    	aa := [3]int{
        1, 2, 3}
    	bb := [3]int{
        4, 5 ,6}
    	cc := [3]int{
        7, 8, 9}
    	// 定义指针数组类型为数组指针类型
    	var arr_pointarr [3] * [3]int = [3]*[3]int{
        &aa,  &bb, &cc}
    	// 遍历三个数组值
    	for i := 0; i < len(arr_pointarr); i++{
        
    		fmt.Println(*arr_pointarr[i]) // 每个指针的值，即aa, bb, cc
    		for j := 0; j < len(*arr_pointarr[i]); j++{
        
    			// 注意[]的优先级高于*
    			fmt.Println((*arr_pointarr[i])[j]) // 再次取aa, bb, cc中的值
    		}
    	}
    	// 将cc中的9， 改成999
    	(*arr_pointarr[2])[2] = 999
    	fmt.Println(cc) //[7 8 999]
    }

### 5.6: 切片指针 ###

package main
    
    import "fmt"
    
    func main(){
        
    	// 1: 定义一个切片, 打印切片存储的地址（数据地址）
    	slice := []int{
        1, 2, 3, 4, 5}
    	// 直接打印切片，打印的是数据所在地址。
    	fmt.Printf("切片的地址是：%p\n", slice) // 切片的地址是：0xc00000c360
    	// 2：定义一个指针，保存切片的地址。
    	p := &slice
    	fmt.Printf("指针存储的地址：%p\n", p) // 指针存储的地址：0xc000004078
    	// 综上所述：指针保存的是切片的地址，切片保存的是数据的地址。
    
    	// 3： 打印pd的类型
    	fmt.Printf("切片指针的类型：%T\n", p) // 切片指针的类型：*[]int
    
    	// 4: 切片指针如何才能遍历到数据呢？
    	for i := 0; i < len(*p); i++{
        
    		fmt.Println((*p)[i])
    	}
    
    
    	// 5: 使用切片指针修改元素
    	(*p)[1] = 222
    	fmt.Println(*p) // [1 222 3 4 5]
    
    	// 6：切片与函数
    	 sss := []int{
        1, 2, 3, 4, 5, 6, 7, 8}
    	 test3(sss)
    	 fmt.Println(sss) // [1 2 3 4 5 6 7 8]
    	 // 切片指针作为函数参数
    	 ppp := &sss
    	 test4(ppp)
    	 fmt.Println(sss) // [1 2 3 4 5 6 7 8 1 2 3]
    
    
    }
    
    func test4(s *[]int){
        
    	// 当使用append后，会新开辟一个空间，然后让让sss重新保存这个新的地址空间
    	*s = append(*s, 1, 2, 3)
    }
    
    func test3(s []int){
        
    	// 使用append导致内存地址改变
    	s = append(s, 1, 2 ,3, )
    }

### 5.7：结构体指针 ###

### 5.8：多级指针： ###

package main
    
    import "fmt"
    
    func main(){
        
    	// 1：案例： 写一个二级指针
    	a := 10
    	p := &a // 一级指针，指向数据的地址
    	pp := &p // 此时的pp一个二级指针，指向一级指针
    	fmt.Printf("二级指针的类型：%T\n", pp) // 二级指针的类型：**int
    
    	// 2: 多级指针的定义
    	// var ppp ***int
    	// var pppp ****int
    }

## 六：内存模型： ##

*  初始0-255:系统占用：
 *  代码区：计算机指令， （只读， 共享）
 *  数据区（初始化数据区， 未初始化数据区， 常量区）
    
     *  初始化数据区和未初始化数据区存放：全局变量
     *  常量区存放：const, iota
 *  堆区：允许用户随意访问区域（视频，音频文件， 图片，大文本）
    
     *  GO语言中： string类型， 切片， map， new操作。
 *  栈区：存储变量，变量指向堆区的地址。栈区不允许长度改变。
    
     *  局部变量。（指针， 变量）
     *  函数的信息。
 *  注册表：配置信息。
    
     *  在内存最高地址段
     *  程序一旦启动，首先将注册表加载到内存中。
 *  图示：
    
     *  对于代码区和数据区，都是从低地址到高地址进行存储的。
     *  对于堆区，是扫描式见缝插针存储的。
     *  对于栈区，是从高地址到低地进行存储的。
     *  由于函数或者变量，在栈区存储，因此如果我们函数体写的内容太多，让栈区空间得不到有效释放，就会导致栈区溢出的情况。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70]: /images/20221022/a6a9b3beebeb473b9fd1ae096e1929cc.png
[img-xQ3nExC3-1618990977191_C_Users_11737_AppData_Roaming_Typora_typora-user-images_1618745275623.png]: /images/20221022/b9f3c7f666b9453997e3d8faf0927c9f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70 1]: /images/20221022/5aa0ba8f48e247039749f3b3b187861d.png