首页 > 其他分享 >day06 数据类型:指针、切片、字典

day06 数据类型:指针、切片、字典

时间:2024-09-17 09:46:51浏览次数:8  
标签:string int fmt 数据类型 day06 v1 v2 Println 字典

day06 数据类型

Go语言中常见的数据类型有很多,例如:

  • 整型,用于表示整数。
  • 浮点型,用于表示小数。
  • 布尔型,用于表示真/假。
  • 字符串,用于表示文本信息。
  • 数组,用于表示多个数据(数据集合)
  • 指针,用于表示内存地址的类型。
  • 切片,用于表示多个数据(数据集合)
  • 字典,用于表示键值对结合。
  • 结构体,用于自定义一些数据集合。
  • 接口,用于约束和泛指数据类型。

今日概要

  • 切片,用于表示多个数据(数据集合),可以理解为动态数组。 [alex,18,3]
  • 字典,键值对。例如:
  • 指针,用于表示内存地址的类型。

1. 切片

切片,动态数组。

切片是Go中重要的数据类型,每个切片对象内部都维护着:数组指针、切片长度、切片容量 三个数据。

type slice struct {
	array unsafe.Pointer
	len   int
	cap   int
}

image-20200617213213399

在向切片中追加的数据个数大于容量时,内部会自动扩容且每次扩容都当前容量的2倍(当容量超过1024时每次扩容则只增加 1/4容量)。

1.1 创建切片

// 创建切片
var nums []int

// 创建切片
var data = []int{11,22,33}
data:= []int{11,22,33}

// 创建切片
// make只用于 切片、字典、channel
var users = make([]int,1,3)
// 切片的指针类型
var v1 = new([]int)

// 指针类型(nil)
var v2 *[]int

1.2 自动扩容

v1 := make([]int,1,3)

fmt.Println(len(v1),cap(v1))

// 其他
data := make([]int,3)
image-20200620113636908
v1 := make([]int,1,3)

v2 := append(v1,66)

fmt.Println(v1)  // [0 ]
fmt.Println(v2)  // [0,66]

v1[0] = 999
fmt.Println(v1)  // [999 ]
fmt.Println(v2)  // [999,66]

// 需求:有一个切片,请往一个切片中追加一个数据。
v3 := make([]int,1,3)
v3 = append(v3,999)
image-20200620114104494
v1 := []int{11,22,33}
v2 := append(v1,44)

v1[0] = 999

fmt.Println(v1) // [999 22 33]
fmt.Println(v2) // [11 22 33 44]

image-20200620114904089

1.3 常见操作

1.3.1 长度和容量

v1 := []int{11,22,33}
fmt.Println(len(v1), cap(v1))

1.3.2 索引

v1 := []string{"alex","李杰","老男孩"}
v1[0]
v1[1]
v1[2]

v2 := make([]int,2,5)
v2[0]
v2[1]
v2[2]  // 报错


v2[0] = 999

1.3.3 切片

v1 := []int{11,22,33,44,55,66}

v2 := v1[1:3]
v3 := v1[1:]
v4 := v1[:3]

// 注意:通过切片切出来的数据和原切片内部存储的数据地址相同

1.3.4 追加

/*
 @Author:武沛齐  微信号:wupeiqi666
 @Description: 老男孩IT教育 & 路飞学城
 @Video:  https://space.bilibili.com/283478842
*/
package main

import (
	"fmt"
)

func main() {
	v1 := []int{11,22,33}

	v2 := append(v1,44)

	v3 := append(v1,55,66,77,88)

	v4 := append(v1, []int{100,200,300}...)

	fmt.Println(v2)
	fmt.Println(v3)
	fmt.Println(v4)
}

>>> 输出
[11 22 33 44]
[11 22 33 55 66 77 88]
[11 22 33 100 200 300]

1.3.5 删除

/*
 @Author:武沛齐  微信号:wupeiqi666
 @Description: 老男孩IT教育 & 路飞学城
 @Video:  https://space.bilibili.com/283478842
*/
package main

import "fmt"

func main() {
	v1 := []int{11, 22, 33, 44, 55, 66}
	deleteIndex := 2

	// 切片获取到 {11,22,44、55、66}
	// 又获取到 {44, 55, 66},将44、55、66要追加到
	result := append(v1[:deleteIndex], v1[deleteIndex+1:]...)
	fmt.Println(result) // [11 22 44 55 66]
	fmt.Println(v1)     //[11 22 44 55 66 66]
}

注意:使用切片时不太会使用删除。【链表】

1.3.6 插入

/*
 @Author:武沛齐  微信号:wupeiqi666
 @Description: 老男孩IT教育 & 路飞学城
 @Video:  https://space.bilibili.com/283478842
*/
package main

import "fmt"

func main() {
	v1 := []int{11, 22, 33, 44, 55, 66}
	insertIndex := 3 // 在索引3的位置插入99

	result := make([]int, 0, len(v1)+1)
	result = append(result, v1[:insertIndex]...)
	result = append(result,99)
	result = append(result,v1[insertIndex:]...)
	fmt.Println(result)
}

注意:效率低下。【链表】

1.3.7 循环

/*
 @Author:武沛齐  微信号:wupeiqi666
 @Description: 老男孩IT教育 & 路飞学城
 @Video:  https://space.bilibili.com/283478842
*/
package main

import "fmt"

func main() {
	v1 := []int{11, 22, 33, 99, 55, 66}

	for i := 0; i < len(v1); i++ {
		fmt.Println(i, v1[i])
	}

	for index, value := range v1 {
		fmt.Println(index, value)
	}
}

1.4 切片嵌套

/*
 @Author:武沛齐  微信号:wupeiqi666
 @Description: 老男孩IT教育 & 路飞学城
 @Video:  https://space.bilibili.com/283478842
*/
package main

import "fmt"

func main() {
	v1 := []int{11, 22, 33, 99, 55, 66}
	v2 := [][]int{[]int{11, 22, 33, 44}, []int{44, 55}}
	v3 := [][2]int{[2]int{1, 2}, [2]int{4, 5}}

	fmt.Println(v1)
	fmt.Println(v2)
	fmt.Println(v3)

	v1[0] = 111111
	v2[0][2] = 222222
	v3[1][0] = 99999

	fmt.Println(v1)
	fmt.Println(v2)
	fmt.Println(v3)
}

1.5 变量赋值

  • 整型

    /*
     @Author:武沛齐  微信号:wupeiqi666
     @Description: 老男孩IT教育 & 路飞学城
     @Video:  https://space.bilibili.com/283478842
    */
    package main
    
    import "fmt"
    
    func main() {
    	v1 := 1
    	v2 := v1
    
    	fmt.Printf("v1的内存地址:%p \n", &v1) // 0xc0000b4008
    	fmt.Printf("v2的内存地址:%p \n", &v2) // 0xc0000b4010
    }
    
  • 布尔类型

    /*
     @Author:武沛齐  微信号:wupeiqi666
     @Description: 老男孩IT教育 & 路飞学城
     @Video:  https://space.bilibili.com/283478842
    */
    package main
    
    import "fmt"
    
    func main() {
    	v1 := false
    	v2 := v1
    
    	fmt.Printf("v1的内存地址:%p \n", &v1) // 0xc00012a002
    	fmt.Printf("v2的内存地址:%p \n", &v2) // 0xc00012a003
    }
    
  • 浮点型

    /*
     @Author:武沛齐  微信号:wupeiqi666
     @Description: 老男孩IT教育 & 路飞学城
     @Video:  https://space.bilibili.com/283478842
    */
    package main
    
    import "fmt"
    
    func main() {
    	v1 := 3.14
    	v2 := v1
    
    	fmt.Printf("v1的内存地址:%p \n", &v1) // 0xc000016050
    	fmt.Printf("v2的内存地址:%p \n", &v2) // 0xc000016058
    }
    
    
  • 字符串

    /*
     @Author:武沛齐  微信号:wupeiqi666
     @Description: 老男孩IT教育 & 路飞学城
     @Video:  https://space.bilibili.com/283478842
    */
    package main
    
    import "fmt"
    
    func main() {
    	v1 := "武沛齐"
    	v2 := v1
    
    	fmt.Printf("v1的内存地址:%p \n", &v1) // 0xc000010200
    	fmt.Printf("v2的内存地址:%p \n", &v2) // 0xc000010210 
    }
    

    image-20200620234120353
    注意:字符串内部元素不可被修改。

  • 数组

    /*
     @Author:武沛齐  微信号:wupeiqi666
     @Description: 老男孩IT教育 & 路飞学城
     @Video:  https://space.bilibili.com/283478842
    */
    package main
    
    import "fmt"
    
    func main() {
    	v1 := [2]int{6, 9}
    	v2 := v1
    	fmt.Println(v1, v2)
    	fmt.Printf("v1的内存地址:%p \n", &v1) // 0xc0000b4010
    	fmt.Printf("v2的内存地址:%p \n", &v2) // 0xc0000b4020
    
    	v1[0] = 11111
    	fmt.Println(v1, v2)
    }
    
    
  • 切片

    /*
     @Author:武沛齐  微信号:wupeiqi666
     @Description: 老男孩IT教育 & 路飞学城
     @Video:  https://space.bilibili.com/283478842
    */
    package main
    
    import "fmt"
    
    func main() {
    	v1 := []int{6, 9}
    	v2 := v1
    	fmt.Println(v1, v2)              // [6 9] [6 9]
    	fmt.Printf("v1的内存地址:%p \n", &v1) // 0xc0000a6020
    	fmt.Printf("v2的内存地址:%p \n", &v2) // 0xc0000a6040
    
    	v1[0] = 11111
    	fmt.Println(v1, v2) // [11111 9] [11111 9]
    }
    
    

    image-20200620234833936
    如果扩容,那么内部存储数据的数组就会重新开辟区域。

    package main
    
    import "fmt"
    
    func main() {
    	v1 := []int{6, 9}
    	v2 := v1
    	fmt.Println(v1, v2)              // [6 9] [6 9]
    	fmt.Printf("v1的内存地址:%p \n", &v1) // 0xc0000a6020
    	fmt.Printf("v2的内存地址:%p \n", &v2) // 0xc0000a6040
    
    	v1 = append(v1, 999)
    	fmt.Println(v1, v2) // [11111 9] [11111 9]
    }
    
    

总结,目前所学的所有的数据类型中,在修改切片的内部元素时,会造成所有的赋值的变量同时修改(不扩容)。

扩展:引用类型和值类型

1.6 练习题

  1. 简述切片和数组的区别?

  2. 简述new和make的区别?

  3. 看代码写结果

    v1 := make([]int,2,5)
    fmt.Println(v1[0],len(v1),cap(v1))
    
  4. 看代码写结果

    v1 := make([]int,2,5)
    v2 := append(v1,123)
    
    fmt.Println(len(v1),cap(v1)) // 2,5
    fmt.Println(len(v2),cap(v2)) // 3,5
    fmt.Println(v1) // [0 0]
    fmt.Println(v2) // [0 0 123]
    

    image-20200621002506511

  5. 看代码写结果

    v1 := make([]int,2,5)
    v2 := append(v1,123)
    v1[0] = 999
    
    fmt.Println(v1) // [999 0]
    fmt.Println(v2) // [999, 0, 123]
    
  6. 看代码写结果

    v1 := make([]int,2,2)
    v2 := append(v1,123)
    v1[0] = 999
    
    fmt.Println(v1) // [999 0]
    fmt.Println(v2) // [0 0 123]
    

    image-20200621002905735

  7. 看代码写结果

    v1 := make([]int,2,2)
    v2 := v1[0:2]
    
    v1[0] = 111
    
    fmt.Println(v1) // [111,0]
    fmt.Println(v2) // [111,0]
    
  8. 看代码写结果

    v1 := [][]int{ []int{11, 22, 33, 44},  []int{44, 55} }
    v1[0][2] = 999
    fmt.Println(v1) // [ [11 22 99 44]  [44,55] ]
    
  9. 看代码写结果

    v1 := [][]int{[]int{11, 22, 33, 44}, []int{44, 55}}
    v2 := v1[0]
    
    v2[2] = 69
    fmt.Println(v1)  // [[11 22 69 44] [44 55]]
    
  10. 看代码写结果

    v1 := [][]int{[]int{11, 22, 33, 44}, []int{44, 55}}
    v2 := append(v1[0],99)
    
    v2[2] = 69
    fmt.Println(v1) // [[11 22 33 44] [44 55]]
    
  11. 看代码写结果

    v1 := [][]int{ make([]int, 2, 5), make([]int, 2, 3) }
    v2 := append(v1[0], 99)
    
    fmt.Println(v1) // [ [0 0], [0 0 ] ]
    fmt.Println(v2) // [0 0 99]
    
    v2[0] = 69
    fmt.Println(v1) // [ [69 0], [0 0 ] ]
    fmt.Println(v2) // [69 0 99]
    

2.字典类型(Map)

在学习任何的编程语言时,一般都会一种数据类型称为:字典(dict)或映射(map),以键值对为元素的数据集合。例如:

{
	"age":"18",
	"name":"武沛齐",
	"email":"[email protected]"
}

这种类型最大的特点就是查找速度非常快,因为他的底层存储是基于哈希表存储的(不同语言还会有一些差异)。

取模+拉链法来快速了解下哈希表存储原理,如下图:

image-20201006100506181

这种结构之所以快,是因为根据key可以直接找到数据存放的位置;而其他的数据类型是需要从前到后去逐一比对,相对来说比较耗时。

以上只是基本的存储模型,而各个编程语言中的字典都会在此基础上进行相应的修改和优化(后续会深入讲解Golang中的map实现机制)。

Map的特点:

  • 键不能重复
  • 键必须可哈希(目前我们已学的数据类型中,可哈希的有:int/bool/float/string/array)
  • 无序

接下来关于map我会从两个维度来进行讲解:

  • 常见使用
  • 底层原理剖析(面试常问)

2.1 声明&初始化

// userInfo := map[string]string{}
userInfo := map[string]string{"name":"武沛齐","age":"18"}

userInfo["name"]  // 武沛齐
userInfo["age"] = "20"
userInfo["email"] = "[email protected]"
// data := make(map[int]int, 10)
data := make(map[int]int)
data[100] = 998
data[200] = 999
data := make(map[string]int)
data["100"] = 998
data["200"] = 999

// 声明,nil
var row map[string]int
row = data
data := make(map[string]int)
data["100"] = 998
data["200"] = 999

// 声明,nil
value := new(map[string]int)
// value["k1"] = 123  # 报错
value = &data

注意:键不重复 & 键必须可哈希(int/bool/float/string/array)

v1 := make(map[[2]int]float32)
v1[[2]int{1,1}] = 1.6
v1[[2]int{1,2}] = 3.4

v2 := make(map[[2]int][3]string )
v2[[2]int{1,1}] = [3]string{"武沛齐","alex","老妖"}

2.2 常用操作

2.2.1 长度和容量

data := map[string]string{"n1":"武沛齐","n2":"alex"}
value := len(data)  // 2
// 根据参数值(10),计算出合适的容量。
// 一个map 中会包含很多桶,每个桶中可以存放8个键值对。
info := make(map[string]string, 10)

info["n1"] = "武沛齐"
info["n2"] = "alex"

v1 := len(info)  // 2
// v2 := cap(info)  // 报错

2.2.2 添加

data := map[string]string{"n1":"武沛齐","n2":"alex"}
data["n3"] = "eric"

2.2.3 修改

data := map[string]string{"n1":"武沛齐","n2":"alex"}
data["n1"] = "eric"

2..2.4 删除

data := map[string]string{"n1":"武沛齐","n2":"alex"}
delete(data,"n2")

2.2.5 查看

data := map[string]string{"n1":"武沛齐","n2":"alex"}
data["n1"]
data := map[string]string{"n1":"武沛齐","n2":"alex"}
for key,value := range data{
    fmt.Println(key,value)
}
data := map[string]string{"n1":"武沛齐","n2":"alex"}
for key := range data{
    fmt.Println(key) 
}
data := map[string]string{"n1": "武沛齐", "n2": "alex"}
for _, value := range data {
    fmt.Println(value)
}

2.2.6 嵌套

v1 := make(map[string]int)
v2 := make(map[string]string)
v3 := make(map[string]...)
v4 := make(map[string][2]int)
v5 := make(map[string][]int)
v6 := make(map[string]map[int]int)
v7 := make(map[string][2]map[string]string)
v7["n1"] = [2]map[string]string{ map[string]string{"name":"武沛齐","age":"18"},map[string]string{"name":"alex","age":"78"}}
v7["n2"] = [2]map[string]string{ map[string]string{"name":"eric","age":"18"},map[string]string{"name":"seven","age":"78"}}

// 伪代码
v7 = {
    n1:[
        {"name":"武沛齐","age":"18"},
        {"name":"alex","age":"78"}
    ],
    n2:[
        {"name":"eric","age":"18"},
        {"name":"seven","age":"78"}
    ]
}

前提:键不重复 & 键必须可哈希

v8 := make(map[int]int)
v9 := make(map[string]int)
v10 := make(map[float32]int)
v11 := make(map[bool]int)
v12 := make(map[ [2]int ]int)
v13 := make(map[ []int ]int) // 错误,不可哈希
v14 := make(map[ map[int]int ]int) // 错误,不可哈希
v15 := make(map[ [2][]int ]int) // 报错
v16 := make(map[ [2]map[string]string ]int) // 报错

2.2.7 变量赋值

v1 := map[string]string{"n1":"武沛齐","n2":"alex"}
v2 := v1

v1["n1"] = "wupeiqi"

ftm.Println(v1) // {"n1":"wupeiqi","n2":"alex"}
ftm.Println(v2) // {"n1":"wupeiqi","n2":"alex"}

特别提醒:无论是否存在扩容都指向同一个地址。

2.3 Map底层原理剖析

Golang中的Map有自己的一套实现原理,其核心是由hmapbmap两个结构体实现。

image-20200919191800912

2.3.1 初始化

// 初始化一个可容纳10个元素的map
info = make(map[string]string,10)
  • 第一步:创建一个hmap结构体对象。

  • 第二步:生成一个哈希因子hash0 并赋值到hmap对象中(用于后续为key创建哈希值)。

  • 第三步:根据hint=10,并根据算法规则来创建 B,当前B应该为1。

    hint            B
    0~8				0
    9~13            1
    14~26           2
    ...
    
  • 第四步:根据B去创建去创建桶(bmap对象)并存放在buckets数组中,当前bmap的数量应为2.

    • 当B<4时,根据B创建桶的个数的规则为:$2^B$(标准桶)
    • 当B>=4时,根据B创建桶的个数的规则为:$2^B$ + $2^{B-4}$(标准桶+溢出桶)

    注意:每个bmap中可以存储8个键值对,当不够存储时需要使用溢出桶,并将当前bmap中的overflow字段指向溢出桶的位置。

image-20200919191800912

2.3.2 写入数据

info["name"] = "武沛齐"

在map中写入数据时,内部的执行流程为:

  • 第一步:结合哈希因子和键 name生成哈希值 011011100011111110111011011

  • 第二步:获取哈希值的后B位,并根据后B为的值来决定将此键值对存放到那个桶中(bmap)。

    将哈希值和桶掩码(B个为1的二进制)进行 & 运算,最终得到哈希值的后B位的值。假设当B为1时,其结果为 0 :
    哈希值:011011100011111110111011010
    桶掩码:000000000000000000000000001
    结果:  000000000000000000000000000 = 0
    
    通过示例你会发现,找桶的原则实际上是根据后B为的位运算计算出 索引位置,然后再去buckets数组中根据索引找到目标桶(bmap)。
    
  • 第三步:在上一步确定桶之后,接下来就在桶中写入数据。

    获取哈希值的tophash(即:哈希值的`高8位`),将tophash、key、value分别写入到桶中的三个数组中。
    如果桶已满,则通过overflow找到溢出桶,并在溢出桶中继续写入。
    
    注意:以后在桶中查找数据时,会基于tophash来找(tophash相同则再去比较key)。
    
  • 第四步:hmap的个数count++(map中的元素个数+1)

image-20200919191800912

2.3.3 读取数据

value := info["name"]

在map中读取数据时,内部的执行流程为:

  • 第一步:结合哈希引子和键 name生成哈希值。

  • 第二步:获取哈希值的后B位,并根据后B为的值来决定将此键值对存放到那个桶中(bmap)。

  • 第三步:确定桶之后,再根据key的哈希值计算出tophash(高8位),根据tophash和key去桶中查找数据。

    当前桶如果没找到,则根据overflow再去溢出桶中找,均未找到则表示key不存在。
    

image-20200919191800912

2.3.4 扩容

在向map中添加数据时,当达到某个条件,则会引发字典扩容。

扩容条件:

  • map中数据总个数 / 桶个数 > 6.5 ,引发翻倍扩容。
  • 使用了太多的溢出桶时(溢出桶使用的太多会导致map处理速度降低)。
    • B <=15,已使用的溢出桶个数 >= $2^B$ 时,引发等量扩容。
    • B > 15,已使用的溢出桶个数 >= $2^{15}$ 时,引发等量扩容。
func hashGrow(t *maptype, h *hmap) {
	// If we've hit the load factor, get bigger.
	// Otherwise, there are too many overflow buckets,
	// so keep the same number of buckets and "grow" laterally.
	bigger := uint8(1)
	if !overLoadFactor(h.count+1, h.B) {
		bigger = 0
		h.flags |= sameSizeGrow
	}
	oldbuckets := h.buckets
	newbuckets, nextOverflow := makeBucketArray(t, h.B+bigger, nil)
	...
}

当扩容之后:

  • 第一步:B会根据扩容后新桶的个数进行增加(翻倍扩容新B=旧B+1,等量扩容 新B=旧B)。
  • 第二步:oldbuckets指向原来的桶(旧桶)。
  • 第三步:buckets指向新创建的桶(新桶中暂时还没有数据)。
  • 第四步:nevacuate设置为0,表示如果数据迁移的话,应该从原桶(旧桶)中的第0个位置开始迁移。
  • 第五步:noverflow设置为0,扩容后新桶中已使用的溢出桶为0。
  • 第六步:extra.oldoverflow设置为原桶(旧桶)已使用的所有溢出桶。即:h.extra.oldoverflow = h.extra.overflow
  • 第七步:extra.overflow设置为nil,因为新桶中还未使用溢出桶。
  • 第八步:extra.nextOverflow设置为新创建的桶中的第一个溢出桶的位置。

image-20200920154253729

2.3.5 迁移

扩容之后,必然要伴随着数据的迁移,即:将旧桶中的数据要迁移到新桶中。

翻倍扩容

如果是翻倍扩容,那么迁移规就是将旧桶中的数据分流至新的两个桶中(比例不定),并且桶编号的位置为:同编号位置 和 翻倍后对应编号位置。

image-20201006081842270

那么问题来了,如何实现的这种迁移呢?

首先,我们要知道如果翻倍扩容(数据总个数 / 桶个数 > 6.5),则新桶个数是旧桶的2倍,即:map中的B的值要+1(因为桶的个数等于$2B$,而翻倍之后新桶的个数就是$2B$ * 2 ,也就是$2^{B+1}$,所以 新桶的B的值=原桶B + 1 )。

迁移时会遍历某个旧桶中所有的key(包括溢出桶),并根据key重新生成哈希值,根据哈希值的 底B位 来决定将此键值对分流道那个新桶中。

image-20201006085640008

扩容后,B的值在原来的基础上已加1,也就意味着通过多1位来计算此键值对要分流到新桶位置,如上图:

  • 当新增的位(红色)的值为 0,则数据会迁移到与旧桶编号一致的位置。
  • 当新增的位(红色)的值为 1,则数据会迁移到翻倍后对应编号位置。

例如:

旧桶个数为32个,翻倍后新桶的个数为64。
在重新计算旧桶中的所有key哈希值时,红色位只能是0或1,所以桶中的所有数据的后B位只能是以下两种情况:
	- 000111【7】,意味着要迁移到与旧桶编号一致的位置。
	- 100111【39】,意味着会迁移到翻倍后对应编号位置。
	
特别提醒:同一个桶中key的哈希值的低B位一定是相同的,不然不会放在同一个桶中,所以同一个桶中黄色标记的位都是相同的。
等量扩容

如果是等量扩容(溢出桶太多引发的扩容),那么数据迁移机制就会比较简单,就是将旧桶(含溢出桶)中的值迁移到新桶中。

这种扩容和迁移的意义在于:当溢出桶比较多而每个桶中的数据又不多时,可以通过等量扩容和迁移让数据更紧凑,从而减少溢出桶。

3.指针

指针,是一种数据类型,用于表示数据的内存地址。

// 声明一个 字符串类型 的变量(默认初始化值为空字符串)。
var v1 string

// 声明一个 字符串的指针类型 的变量(默认初始化值为nil)。
var v2 *string 

var v3 int

var v4 *int
// 声明一个 字符串类型 的变量,值为 武沛齐。
var name string = "武沛齐"

// 声明一个 字符串的指针类型 的变量,值为 name 对应的内存地址。
var pointer *string = &name

var age int = 18
var x1 *int = &age
image-20201030144654619

3.1 指针的意义

相当于创建了一个地址的引用,以后根据这个引用再去获取他里面的值。

image-20201030163932778

/*
 @Author:武沛齐  微信号:wupeiqi666
 @Description: 老男孩IT教育 & 路飞学城
 @Video:  https://space.bilibili.com/283478842
*/
package main

import "fmt"

func main() {
	v1 := "武沛齐"
	v2 := &v1
	fmt.Println(v1, v2, *v2) // 武沛齐 0xc00008e1e0 武沛齐
  
  v1 = "alex"
  fmt.Println(v1, v2, *v2) // alex 0xc00008e1e0 alex
}

3.2 指针的应用场景

场景1:

v1 := "武沛齐"
v2 := v1
v1 = "alex"

fmt.Println(v1,v2) // alex 武沛齐
v1 := "武沛齐"
v2 := &v1
v1 = "alex"
fmt.Println(v1,*v2) // alex  alex
image-20201030170159212

场景2:

package main

import "fmt"

func changeData(data string) {
	data = "哈哈哈哈哈"
}

func main() {
	name := "武沛齐"
  // 本质上会将name的值拷贝一份,并赋值给data
	changeData(name)
  fmt.Println(name) // 武沛齐
}
package main

import "fmt"

func changeData(ptr *string) {
	*ptr = "哈哈哈哈哈"
}

func main() {
	name := "武沛齐"
	changeData(&name)
  fmt.Println(name) // 哈哈哈哈哈
}

场景3:

package main

import "fmt"

func main() {
	var username string
	fmt.Printf("请输入用户名:")
	
  // 提示用户输入,当用户输入之后,将输入的值赋值给内存地址对应的区域中。
	fmt.Scanf("%s", &username)

	if username == "武沛齐" {
		fmt.Println("登录成功")
	} else {
		fmt.Println("登录失败")
	}
}

3.3 指针的指针

name := "武沛齐"

// 声明一个指针类型变量p1,内部存储name的内存地址
var p1 *string = &name

// 声明一个指针的指针类型变量p2,内部存储指针p1的内存地址
var p2 **string = &p1

// 声明一个指针的指针的指针类型变量p3,内部存储指针p2的内存地址
var p3 ***string = &p2
image-20201030172324426

因为有指针的指针存在,所以在使用指针进行重置值时,也需要将相应的*号设置好,例如:

package main

import "fmt"

func main() {
   name := "武沛齐"

   // 声明一个指针类型变量p1,内部存储name的内存地址
   var p1 *string = &name
  
   *p1 = "张三" // 将name的内存中的值由 武沛齐 改为 张三

   // 声明一个指针的指针类型变量p2,内部存储指针p1的内存地址
   var p2 **string = &p1
   **p2 = "啦啦啦" // 将name的内存中的值由 张三 改为 啦啦啦

   var p3 ***string = &p2
   ***p3 = "我靠" // 将name的内存中的值由 啦啦啦 改为 我靠
}

3.4 指针小高级操作

  • 数组的地址 == 数组的第一个元素的地址。
    image-20201030181305133

    dataList := [3]int8{11, 22, 33}
    
    fmt.Printf("数组的地址:%p;数组第一个元素的地址:%p \n", &dataList, &dataList[0])
    // &dataList 和 &dataList[0] 的内存中存储的数据虽然相同,但他们是两个不同类型的指针。
    // &dataList 是 *[3]int8 类型
    // &dataList[0] 是 *int8 类型
    
  • 指针的计算

    /*
     @Author:武沛齐  微信号:wupeiqi666
     @Description: 老男孩IT教育 & 路飞学城
     @Video:  https://space.bilibili.com/283478842
    */
    package main
    
    import (
    	"fmt"
    	"unsafe"
    )
    
    func main() {
    
    	dataList := [3]int8{11, 22, 33}
    
    	// 1.获取数组第一个元素的地址(指针)
    	var firstDataPtr *int8 = &dataList[0]
    
    	// 2.转换成Pointer类型
    	ptr := unsafe.Pointer(firstDataPtr)
    
    	// 3.转换成uintptr类型,然后进行内存地址的计算(即:地址加1个字节,意味着取第2个索引位置的值)。
    	targetAddress := uintptr(ptr) + 1
    
    	// 4.根据新地址,重新转换成Pointer类型
    	newPtr := unsafe.Pointer(targetAddress)
    
    	// 5.Pointer对象转换为 int8 指针类型
    	value := (*int8)(newPtr)
    
    	// 6.根据指针获取值
    	fmt.Println("最终结果为:", *value)
    }
    
    

标签:string,int,fmt,数据类型,day06,v1,v2,Println,字典
From: https://www.cnblogs.com/fuminer/p/18416927

相关文章

  • day05 数据类型
    day05数据类型写程序等价于写作文数据类型,其实就是各种各样类型的数据。Go语言中常见的数据类型有挺多,例如:整型,用于表示整数。浮点型,用于表示小数。布尔型,用于表示真/假。字符串,用于表示文本信息。数组,用于表示多个数据(数据集合)指针,用于表示内存地址的类型。切片......
  • 【Go开发】Go语言基本语法入门:数据类型与方法定义
    文章目录环境准备一、引言二、Var关键字三、数据类型1.整型符号表示值的范围2.浮点型精度范围性能3.布尔型4.字符串三、变量声明1.指定变量类型2.自动推导类型3.批量声明四、方法定义五、总结环境准备开发环境:MacOSGo版本:goversiongo1.23.1darwin/am......
  • 06_Python数据类型_元组
    Python的基础数据类型数值类型:整数、浮点数、复数、布尔字符串容器类型:列表、元祖、字典、集合元组元组(Tuple)是一种不可变的序列类型,与列表类似,但有一些关键的区别。本质:只读的列表(list)定义元组元组是由圆括号()包围的元素集合,元素之间用逗号分隔。元组一旦创建,其内......
  • 【Python学习笔记】 第8章 列表与字典
    列表Python的列表是:任意对象的有序集合通过偏移访问可变长度、异构以及任意嵌套属于“可变序列”的分类对象引用数组下表是常见/具有代表性的列表对象操作:操作解释L=[]一个空的列表L=[123,'abc',1.23,{}]有四个项的列表,索引从0到3L=......
  • Vue框架;Vue中的选择和循环结构;Vue数据类型;Vue中的事件和动态属性;Vue子组件通过导入在
    一,Vue简介        前端现在比较火的三大框架就是:vue,React,Angular。在国内使用最多的还是:    vue>React >Angular        Vue(发音为/vjuː/,类似view)是一款用于构建用户界面的JavaScript框架。它基于标准HTML、CSS和JavaScript构建,并提......
  • 【Scala入门学习】基本数据类型和变量声明
    1.基本数据类型scala的基本类型有9种:Byte、Char、Short、Int、Long、Float、Double、Boolean、UnitScala中没有基本数据类型的概念,所有的类型都是对象。AnyVal:代表所有基本类型。AnyRef:代表所以引用类型,包括Scalaclass和Javaclass。Any:是所有类的超类。如果不知......
  • 字典的定义及其应用
    在Python中,字典(dictionary)是一种可变的、无序的容器数据类型,用于存储键值对(key-valuepairs)。一、定义字典使用花括号 {} 和冒号 : 来定义字典,键和值之间用冒号分隔,不同的键值对之间用逗号分隔。例如:   my_dict= {'name': 'Alice', 'age': 30, 'city': ......
  • 数据类型与底层原理
    数据类型与底层原理数据结构哈希表redis使用链式哈希来解决哈希冲突,其Hash表实质上是一个二维数组,其中每一项就是一个指向哈希项(dictEntry)的指针typedefstructdictht{dictEntry**table;//二维数组unsignedlongsize;//Hash表大小unsignedlongsizemask......
  • java实际开发——涉及金额时使用的数据类型BigDecimal
    目录首先说结论,使用BigDecimal类。为什么不用其它的类型?(比如int、long、float、double)1、整型:2、浮点型:BigDecimal类基本数据类型与BigDecimal使用时的差别:1、创建2、+-*/3、比较标度(Scale)舍入模式首先说结论,使用BigDecimal类。为什么不用其它的类型?(比......
  • python容器四之字典
    文章目录1.字典介绍2.使用字典3.字典的常见操作3.1添加元素3.2删除元素3.3修改元素3.4查找元素4.字典遍历方法4.1遍历字典元素5.公共运算符6.公共方法1.字典介绍先来看看现实生活中的字典。我们知道,可以应用字典来查找汉字。在这里插入图片描述接着......