Go基礎編程：指針（pointer）

原文鏈接：http://oldchen.iwulai.com/index.php/2019/01/14/go%E5%9F%BA%E7%A1%80%E7%BC%96%E7%A8%8B%EF%BC%9A%E6%8C%87%E9%92%88%EF%BC%88pointer%EF%BC%89/

1.什麼是指針

指針是存儲一個變量的內存地址的變量。

Go語言雖然保留了指針，但與其它編程語言不同的是：

• 默認值 nil，沒有 NULL 常量
• 操作符 “&” 取變量地址， “*” 通過指針訪問目標對象
• 不⽀持指針運算，不⽀持 “->” 運算符，直接⽤ “.” 訪問目標成員

變量A 的值是 10，存儲在地址爲 c00004e058的內存中。變量 B存儲了變量 A的地址。現在可以說 B 指向A。

2.指針的聲明

一個指針變量指向了一個值的內存地址。

類似於變量和常量，在使用指針前你需要聲明指針。指針聲明格式如下：

var var_name *var-type

var-type 爲指針類型，var_name 爲指針變量名，* 號用於指定變量是作爲一個指針。以下是有效的指針聲明：

var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮點型 */

本例中這是一個指向 int 和 float32 的指針。

3.如何使用指針

指針使用流程：

• 定義指針變量。
• 爲指針變量賦值。
• 訪問指針變量中指向地址的值。

在指針類型前面加上 * 號（前綴）來獲取指針所指向的內容。

package main
import "fmt"
func main() {
   var a int= 20   /* 聲明實際變量 */
   var ip *int        /* 聲明指針變量 */
   ip = &a  
   /* 指針變量的存儲地址 */
   fmt.Printf("a 變量的地址是: %x\n", &a)//a 變量的地址是: c00004e058
   /* 指針變量的存儲地址 */
   fmt.Printf("ip 變量儲存的指針地址: %x\n", ip)// ip 變量儲存的指針地址: c00004e058
   /* 使用指針訪問值 */
   fmt.Printf("*ip 變量的值: %d\n", *ip)// *ip 變量的值: 20
}

4.Go 空指針

當一個指針被定義後沒有分配到任何變量時，它的值爲 nil。

nil 指針也稱爲空指針。

nil在概念上和其它語言的null、None、nil、NULL一樣，都指代零值或空值。

一個指針變量通常縮寫爲 ptr。

package main
import "fmt"
func main() {
   var  ptr *int //聲明一個Go 空指針
   fmt.Printf("ptr 的值爲 : %x\n", ptr)//ptr 的值爲 : 0
}

空指針判斷：

if(ptr != nil)     /* ptr 不是空指針 */
if(ptr == nil)    /* ptr 是空指針 */

5.指針解引用

解引用指針的意思是通過指針訪問被指向的值。指針 a 的解引用表示爲：*a。

讓我們通過一個程序看一下它是怎麼工作的。

package main  
import ("fmt")
func main() {  
    b := 255
    a := &b
    fmt.Println("address of b is", a)//address of b is 0xc00004e058
    // 將 a 解引用並打印這個解引用得到的值。
    fmt.Println("value of b is", *a)//value of b is 255
}

讓我們再寫一個程序，該程序使用指針改變 b 的值。

package main  
import ("fmt")
func main() {  
    b := 255
    a := &b
    fmt.Println("address of b is", a)//b的地址：address of b is 0xc00004e058
    fmt.Println("value of b is", *a) //a解引用的值爲b：value of b is 255
    *a++//將 a 指向的值自增 1，這樣做也改變了 b 的值，因爲 a 指向 b。因此 b 的值變爲 256
    fmt.Println("new value of b is", b)//new value of b is 256
}

6.傳遞指針給函數

package main  
import ("fmt")
func change(val *int) {  
    *val = 55
}
func main() {  
    a := 58
    fmt.Println("value of a before function call is",a)//58
    b := &a
    change(b)//將指向 a 的指針 b 傳遞給函數 change。在函數 change 內部，通過解引用修改了 a 的值
    fmt.Println("value of a after function call is", a)//55
}

7.不要傳遞指向數組的指針給函數，而是使用切片

假設我們需要通過函數修改一個數組。一個辦法是將數組的指針作爲參數傳遞給函數。

package main

import (  
    "fmt"
)

func modify(arr *[3]int) {  
    (*arr)[0] = 90//通過解引用的方式將數組的第一個元素賦值爲 90。程序輸出爲：[90 90 91]。
}

func main() {  
    a := [3]int{89, 90, 91}
    modify(&a)//數組 a 的地址傳遞給了函數 modify
    fmt.Println(a)//[90 90 91]
}

a[x] 是 (*a)[x] 的簡寫，因此(*arr)[0] 可以替換爲 arr[0]。讓我們用這種簡寫方式重寫上面的程序：

package main

import (  
    "fmt"
)

func modify(arr *[3]int) {  
    arr[0] = 90//通過解引用的方式將數組的第一個元素賦值爲 90。程序輸出爲：[90 90 91]。
}

func main() {  
    a := [3]int{89, 90, 91}
    modify(&a)//數組 a 的地址傳遞給了函數 modify
    fmt.Println(a)//[90 90 91]
}

雖然可以通過傳遞數組指針給函數的方式來修改原始數組的值，但這在 Go 中不是慣用的方式，我們可以使用切片完成同樣的事情。

讓我們用切片的方式重寫上面的程序：

package main

import "fmt"
func modify(sls []int) {  
    sls[0] = 90
}

func main() {  
    a := [3]int{89, 90, 91}
    modify(a[:])//傳遞了一個切片給 modify 函數
    fmt.Println(a)
     // 切片的第一個元素被修改爲 90。程序的輸出爲：[90 90 91]。
    // 所以請不要以數組指針作爲參數傳遞給函數，而是使用切片：）。這樣的代碼更加簡潔，在 Go 中更常被使用。
}

8.Go 不支持指針運算

Go 不支持其他語言（比如C）中的指針運算。

package main

func main() {  
    b := [...]int{109, 110, 111}
    p := &b
    p++//.\main.go:6:6: invalid operation: p++ (non-numeric type *[3]int)
}