从零开始学GO ---- 指针、数组、切片、字典、结构体

以你之姓@ 2022-11-20 04:49 178阅读 0赞

### 从零开始学GO ---- 指针、数组、切片、字典、结构体 ###

#### 指针 ####

Go语言支持指针，指针的声明类型为\* T,多级指针声明为\*\* T,通过在变量名前加&获取变量的地址。

不过区别于C/C++中的指针，Go语言中的指针不能进行偏移和运算，是安全指针。因此，实际上，对于Go中的指针，只需要记住两个符号：`&`（取地址）和`*`（根据地址取值）

var a =11
    p:=&a   //p是一个指针，*p和a的值都是11

通过传入一个变量的地址，可以实现一个函数中改变该变量的目的：

package main
    
    import "fmt"
    
    func modify1(x int) {
           //传入的参数是int，无法改变外部的变量
    	x = 100
    }
    
    func modify2(x *int) {
          //传入的参数是 *int,可以改变外部的变量
    	*x = 100
    }
    
    func main() {
        
    	a := 10
    	modify1(a)
    	fmt.Println(a) // 10
    	modify2(&a)
    	fmt.Println(a) // 100
    }

*  在赋值语句中，\*T出现在"=“左边表示指针声明，\*T出现在”="右边表示取指针指向的值
 *  Go语言中没有"->“操作符，结构体指针访问结构体字段仍然用”."点操作符
    
        type User struct{
              
            name string
            age int
        }
        andes:=User{
              
            name: "andes",
            age: 20,
        }
        p:=&andes
        fmt.Println(p.name)  //输出 andes ，也就是通过"."访问成员变量
 *  Go由于支持垃圾回收，因为如果支持指针运算，会给垃圾回收的实现带来诸多不便，因此在语言层面禁止指针运算。
    
        a:=10
        p:=&a
        p++  //不允许，报错
 *  **Go的函数中允许返回局部变量的地址**
    
    Go编译器通过使用“栈逃逸”机制将这种局部变量的空间分配到堆上
    
        func sum(a,b int) *int{
              
        	sum:=a+b
        	return &sum  //允许，sum将被分配在heap上
        }

#### 数组 ####

Go的数组的类型名是`[n]elementType`,其中`n`是数组长度，`elementType`是数组元素类型。例如：`[2]int` 表示一个长度为2元素类型为`int`的数组。

在Go语言中，数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化，也就是说，数组创建完成后就不可以再追加元素。数组是值类型的，数组的赋值或者作为参数传递都是值拷贝。可以根据数组创建切片。

和其他语言一样，数组可以通过下标进行访问，下标是从`0`开始，最后一个元素下标是：`len-1`，访问越界（下标在合法范围之外），则触发访问越界，会panic

数组的一些初始化方式：

// 定义一个长度为3的元素类型为int的数组a
    var a [3]int
    
    //不指定长度，由初始化列表数量确定长度
    a:=[...]int{1,2,3}
    
    //没有初始化的元素会使用类默认值，int会被初始化为0
    a:=[3]int{1:1,2:3}  //通过索引初始化，所以a[1]=1,a[2]=3,a[0]没有被初始化，默认为0

数组的遍历方式：

func main() {
        
    	var a = [...]string{
        "one", "two", "three"}
        // 方法1：for循环遍历              //len(a)得到数组的长度
    	for i := 0; i < len(a); i++ {
        
    		fmt.Println(a[i])
    	}
    	
    	// 方法2：for range遍历
    	for index, value := range a {
        
    		fmt.Println(index, value)
    	}
    }

多维数组：

//二维数组的定义：
    func main() {
        
    	a := [3][2]string{
        
    		{
        "1-1", "1-2"},
    		{
        "2-1", "2-2"},
    		{
        "3-1", "3-2"},
    	}
    	fmt.Println(a)
    	fmt.Println(a[2][1])
    }
    //  [[1-1 1-2] [2-1 2-2] [3-1 3-2]]
    //  3-2
    
    //二维数组的遍历：
    func main() {
        
    	a := [3][2]string{
        
    		{
        "1-1", "1-2"},
    		{
        "2-1", "2-2"},
    		{
        "3-1", "3-2"},
    	}
    	for _, v1 := range a {
        
    		for _, v2 := range v1 {
        
    			fmt.Printf("%s\t", v2)
    		}
    		fmt.Println()
    	}
    }
    //  1-1     1-2
    //  2-1     2-2
    //  3-1     3-2

#### 切片 ####

Go语言的数组的定长性和值拷贝性质限制了数组的使用场景，Go提供了一种数据类型slice切片来解决，slice是一种变长数组，其数据结构中有指向数组的指针，所以**是一种引用类型**。

切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。切片一般用于快速地操作一块数据集合。

Go为切片维护三个元素：指向底层数组的指针、切片的元素数量、底层数组的容量

type slice struct{
        
        array unsafe.Pointer  //一个指向底层数组的指针
        len int               //切片的元素数量
        cap int               //底层数组的容量
    }

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

##### 切片的创建： #####

*  直接声明切片类型遍历 `var name []T` ,不过通常一个空的切片是没有意义的
    
        var a []int
        fmt.Printf("%v\n",a)  //结果是[]
        var c = []int{
              1, 2} //声明一个int切片并初始化
        fmt.Println(c)      //[1 2]
 *  通过数组创建切片：`array[b:e]` ,其中 `array` 表示数组名，b表示开始索引(不指定的话默认为0)，e表示结束索引(不指定的话默认为len(array))。需要注意的是，`array[b:e]`包含 `e-b`个元素，第一个元素是`array[b]`,最后一个元素是`array[e-1]` ,也就是说，**左闭右开** 切片的cap默认是从切片起始到数组结尾的大小，可以通过`array[b:e:end]` 设置cap的默认结尾
    
        func main() {
              
        	a := [...]int{
              1, 2, 3, 4, 5, 6, 7}
        	s := a[1:3] // s := a[low:high]
        	fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))
            //输出为  s:[2 3] len(s):2 cap(s):6
            s2 := a[1:]
        	fmt.Printf("s:%v len(s):%v cap(s):%v\n", s2, len(s2), cap(s2))
            //s:[2 3 4 5 6 7] len(s):6 cap(s):6
        }
 *  通过内置函数make创建切片，通过make创建的切片各元素会默认初始化为切片元素类型的零值
    
    `make([]T, size, cap)` : T是元素类型，size是切片的len，cap是切片的cap大小
    
        func main() {
              
        	a := make([]int, 2, 10)
        	fmt.Println(a)      //[0 0]
        	fmt.Println(len(a)) //2
        	fmt.Println(cap(a)) //10
        }

##### 切片的一些操作： #####

*  内置函数 len() 返回切片长度，内置函数cap()返回切片底层数组容量
 *  判断切片是否为空，应采用`len(s) == 0`来判断
 *  切片的拷贝赋值，直接通过拷贝赋值的切片，共用一个底层数组，因此对一个切片的修改会影响另一个切片的内容
    
        func main() {
              
        	s1 := make([]int, 3) //[0 0 0]
        	s2 := s1             //将s1直接赋值给s2，s1和s2共用一个底层数组
        	s2[0] = 100
        	fmt.Println(s1) //[100 0 0]
        	fmt.Println(s2) //[100 0 0]
        }
 *  切片的遍历：（和数组遍历方式相同，可以采用for循环或者for range的方式）
    
        func main() {
              
        	s := []int{
              1, 2, 3}
        	//for循环方式
        	for i := 0; i < len(s); i++ {
              
        		fmt.Println(i, s[i])
        	}
        	//for range方式
        	for index, value := range s {
              
        		fmt.Println(index, value)
        	}
        }
        // 0 1
        // 1 2
        // 2 3
 *  内置函数append()对切片添加元素
    
        func main(){
              
        	var s []int
        	s = append(s, 1)        // [1]
        	s = append(s, 2, 3, 4)  // [1 2 3 4]
        	s2 := []int{
              5, 6, 7}  
        	s = append(s, s2...)    // [1 2 3 4 5 6 7]
        }
    
    每个切片会指向一个底层数组，这个数组的容量够用就添加新增元素。当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行“扩容”，此时该切片指向的底层数组就会更换。
 *  内置函数copy()用于复制一个切片，可以迅速地将一个切片的数据复制到另外一个切片空间中，不同于复制拷贝，`copy()`的使用方法：`copy(destSlice, srcSlice)`
    
        func main() {
              
        	// copy()复制切片
        	a := []int{
              1, 2, 3, 4, 5}
        	c := make([]int, 5, 5)
        	copy(c, a)     //使用copy()函数将切片a中的元素复制到切片c
        	fmt.Println(a) //[1 2 3 4 5]
        	fmt.Println(c) //[1 2 3 4 5]
        	c[0] = 1000        //虽然对c[0]进行了修改，但是不影响a
        	fmt.Println(a) //[1 2 3 4 5]
        	fmt.Println(c) //[1000 2 3 4 5]
        }

#### 字典 ####

map是一种无序的基于`key-value`的数据结构，Go语言中的map是引用类型，必须初始化才能使用。

map的类型格式是：`map[K]T` 其中`K`是任意可以进行比较的类型，T是值类型。

##### map的创建： #####

*  使用字面量进行创建：
    
        func main() {
              
        	ma := map[string]int{
              "a": 1, "b": 2}
        	fmt.Println(ma["a"])  //1
        	fmt.Println(ma["b"])  //2
        }
 *  使用内置的make函数进行创建
    
        //  make(map[K]T) --map容量使用默认值
        //  make(map[K]T,len) --map容量为len
        
        func main() {
              
        	mp1 := make(map[int]string)
        	mp2 := make(map[int]string)
        	mp1[1] = "tom"
        	mp2[1] = "pony"
        	fmt.Println(mp1[1]) //tom
        	fmt.Println(mp2[1]) //pony
        }

##### map的一些操作： #####

*  map的单个键值访问格式为`mapName[key]` ,更新某个`key`时将`mapName[key]`放到等号左边，访问某个`key`时将`mapName[key]`放到等号右边
    
        func main() {
              
        	scoreMap := make(map[string]int, 8)
        	scoreMap["Tom"] = 80
        	scoreMap["Pony"] = 60
        	fmt.Println(scoreMap)         //map[Pony:60 Tom:80]
        	fmt.Println(scoreMap["Tom"])   //80
        	fmt.Printf("type of a:%T\n", scoreMap) //type of a:map[string]int
        }
 *  可以使用for range遍历一个map，但是不能保证每次迭代的顺序【遍历map时的元素顺序与添加键值对的顺序无关】
    
        func main() {
              
        	scoreMap := make(map[string]int, 8)
        	scoreMap["Tom"] = 80
        	scoreMap["Pony"] = 60
        	scoreMap["Lisa"] = 90
        	for k, v := range scoreMap {
              
        		fmt.Println(k, v)
        	}
        }
        //Lisa 90
        //Tom 80
        //Pony 60
 *  使用delete()函数删除键值对 `delete(mapName,key)`
    
        func main() {
              
        	scoreMap := make(map[string]int, 8)
        	scoreMap["Tom"] = 80
        	scoreMap["Pony"] = 60
        	scoreMap["Lisa"] = 90
        	delete(scoreMap, "Tom")
        	for k, v := range scoreMap {
              
        		fmt.Println(k, v)
        	}
        }
        //Lisa 90
        //Pony 60
 *  可以使用内置的len()函数返回map中的键值对数量

#### 结构体 ####

Go语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念。Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性。

struct结构中的类型可以是任意类型，struct的存储空间是连续的，其字段按照声明时候的顺序存放(**注意字段之间有对齐要求**）

struct有两种类型：

*  struct类型字面量
    
        struct{
              
            FeildName FeildType
            FeildName FeildType
            FeildName FeildType
        }
 *  **使用type声明的自定义struct类型**
    
        type TypeName struct{
              
            FeildName FeildType
            FeildName FeildType
            FeildName FeildType
        }

例如定义一个人的信息，包括名字、年龄、城市：

type person struct {
        
    	name string
    	city string
    	age  int8
    }

只有当结构体实例化时，才会真正地分配内存。也就是必须实例化后才能使用结构体的字段。

**结构体的实例化：**

可以通过`.`来访问结构体的字段（成员变量）进行实例化，也可以声明时初始化。

type person struct {
        
    	name string
    	city string
    	age  int8
    }
    
    func main() {
        
    	var p1 person
    	p1.name = "Tom"
    	p1.city = "NewYork"
    	p1.age = 18
    	p2 := person{
        name: "Pony", city: "LA", age: 19}
    	fmt.Printf("p1=%v\n", p1)  //p1={Tom NewYork 18}
    	fmt.Printf("p2=%v\n", p2)  //p2={Pony LA 19}
    	fmt.Printf("p1=%#v\n", p1) //p1=main.person{name:"Tom", city:"NewYork", age:18}
    	fmt.Printf("p2=%#v\n", p2) //p2=main.person{name:"Pony", city:"LA", age:19}
    }

结构体还有一些更复杂的细节，将在之后的一个篇章详述

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RpbmdkaW5nZG9kbw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/f186e60ab7a8474a908ad52a78c36357.png