Golang之指针

xuguiyi00 2020-04-22

5.6 指针

5.6.1 什么是指针

  • 指针就是一个变量,用来存储另一个变量的内存地址
func main() {
    // 指针地址,指针类型,指针取值
    // &取地址,*根据地址取值
    a := 10
    b := &a
    fmt.Println(*b)

    //指针类型 *int *unit *float *string *array *struct 等
    
    // 指针的定义
    // var 变量名 指针类型
    var p1 *int  //定义空指针
    p1 = &1
}

5.6.2 数组指针和指针数组

  • 数组指针:是一个指针,用来存储数组的内存地址
func main() {
    arr := [4] int{1, 2, 3, 4}
    fmt.Println(arr)
  
    // 定义一个数组指针
    var p1 *[4] int
    fmt.Println(p1)  // nil 空指针
    fmt.Ptintf("%T\n", p1)  // *[4] int
    
    p1 = &arr1
    fmt.Println(p1)
    fmt.Printf("%p\n", p1)
    fmt.Printf("%p\n", &p1)
    
    // 通过数组指针操作数组
    (*p1)[0] = 100
    // 可以简写为
    // p1[0] = 200
    fmt.Println(arr)  // [100 2 3 4]
}
  • 指针数组:是一个数组,元素为指针
func main() {
    a := 1
    b := 2
    c := 3
    d := 4
    arr1 := [4] int{a, b, c, d}
    arr2 := [4] *int{&a, &b, &c, &4}
    fmt.Println(arr1)
    fmt.Println(arr2)
    
    // 操作数组与指针数组的区别
    //arr1[0] = 100
    //fmt.Println(a)
    //fmt.Println(arr1, &arr1[0])  // 值类型,将a,b,c,d的值拷贝过来放到数组中,修改的是数组空间内的数据,与a,b,c,d没有关系
    //fmt.Println(arr2)
    
    *arr2[0] = 1000
    fmt.Println(a)
    fmt.Println(arr1, &arr1[0])
    fmt.Println(arr2, *arr2[0])       // 通过指针数组中的内存地址,修改了a,b,c,d的值,类似于Python列表
    
    b = 2000
    fmt.Println(b)
    fmt.Println(arr1, &arr1[1])
    fmt.Println(arr2, *arr2[1])
}

总结:

数组是值类型,将值拷贝了一份放到数内存中,二者相互独立,互不影响,修改数组后数组内存中的值改变,不会影响拷贝的源数据,源数据改变,也不会影响数组

Go中切片是对原数组的引用,二者互相关联,修改切片元素的值后,与之关联的底层数组的也会受到影响,同理,底层数组的改变也会影响切片的值

Python中的列表是引用类型,基于指针数组,修改可变元素后(可变类型与不可变类型),引用的源数据也会受到影响---

  • Go中切片与Python中列表的区别
    • go的切片,其成员是相同类型的,python的列表和元组则不限制类型。
    • 两种语言都有[a: b]这种切片操作,意义也类似,但是go的a、b两个参数不能是负数,python可以是负数,此时就相当于从末尾往前数。
    • 两种语言都有[a: b: c]这种切片操作,意义却是完全不同的。go的c,表示的是容量;而python的c表示的是步长
    • python的切片产生的是新的对象,对新对象的成员的操作不影响旧对象;go的切片产生的是旧对象一部分的引用,对其成员的操作会影响旧对象。
    • 底层实现的不同
      • go的切片,底层是一个三元组,一个指针,一个长度,一个容量。指针指向一块连续的内存,长度是已有成员数,容量是最大成员数。切片时,一般并不会申请新的内存,而是对原指针进行移动,然后和新的长度、容量组成一个切片类型值返回。也就是说,go的切片操作通常会和生成该切片的切片共用内存。不仅是切片,字符串、数组的切片也是一样的,通常会共用内存。当然也有异常情况,那就是切片时,提供的容量过大,此时会申请新内存并拷贝;或者对切片append超出容量,也会如此。这时,新的切片,才不会和老切片共享内存。(如果你切片/创建时提供的容量小于长度,会panic)
      • python的列表,其实是个指针数组。当然在下层也会提供一些空位之类的,但基本就是个数组。对它们切片,会创建新的数组,注意,是创建新的数组!python的列表可没有容量的概念。这其实也体现了脚本语言和编译语言的不同。虽然两个语言都有类似的切片操作;但是python主要目标是方便;go主要目标却是快速(并弥补丢弃指针运算的缺陷)。

5.6.3 函数指针与指针函数

// 函数指针
// Go中函数默认就是一个指针类型,不需要*
func main() {
    var a func()
    a = func1
    a()
}
func func1() {
    fmt.Println("这是func1()")
}

// 指针函数
// 返回值为指针的函数
func main() {
    // arr1是数组,值传递,将func1中返回的arr的值拷贝到arr1中,当func1调用结束,arr被销毁
    arr1 := func1()
    fmt.Printf("arr1的类型:%T,内存地址:%p,值:%v\n",arr1, &arr1, arr1)
    
    // arr2是指针类型,值传递,将func2中返回的arr的内存地址保存到arr2中,arr不会随着func2的结束而销毁(和闭包一样改变了变量的生命周期?)
    arr2 := func2()
    fmt.Printf("arr2的类型:%T,内存地址:%p,值:%v\n",arr2, &arr2, arr2)
}

// 这是普通函数
func func1() {
    arr := [4] int{1, 2, 3, 4}
    return arr
}

// 这是指针函数
func func2() *[4] int {
    arr := [4] int{1, 2, 3, 4}
    return &arr
}

5.6.4 指针作为参数

func main() {
    /*
    指针作为参数
    参数:值传递和引用传递
    
    总结:值传递,拷贝一份,不会影响原数据,但消耗内存
         引用传递通过指针操作数据,会改变原数据,但节省内存(拷贝的数据可能很大)
    */
    n := 10
    // 值传递,func1改变不会影响n,a随着func1结束而被销毁
    func1(n)
    fmt.Println(n)

    // 引用传递,将n的内存地址拷贝到a中,通过*a更改了n,a也会随着func2的结束而被销毁,但n已经改变
    func2(&n)
    fmt.Println(n)
}

func func1(a int) {
    a = 100
    fmt.Println(a)
}

func func1(a *int) {
    *a = 100
    fmt.Println(*a)

相关推荐