Go 語言指針

Go 語言中指針是很容易學習的，Go 語言中使用指針可以更簡單的執行一些任務。

接下來讓我們來一步步學習 Go 語言指針。

我們都知道，變量是一種使用方便的占位符，用於引用計算機內存地址。

Go 語言的取地址符是 &，放到一個變量前使用就會返回相應變量的內存地址。

以下實例演示了變量在內存中地址：

package main

import "fmt"

func main() {
   var a int = 10   

   fmt.Printf("變量的地址: %x\n", &a  )
}

變量的地址: 20818a220

什麽是指針

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

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

var var_name *var-type

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

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

如何使用指針

指針使用流程：

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

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

package main

import "fmt"

func main() {
   var a int= 20   /* 聲明實際變量 */
   var ip *int        /* 聲明指針變量 */

   ip = &a  /* 指針變量的存儲地址 */

   fmt.Printf("a 變量的地址是: %x\n", &a  )

   /* 指針變量的存儲地址 */
   fmt.Printf("ip 變量儲存的指針地址: %x\n", ip )

   /* 使用指針訪問值 */
   fmt.Printf("*ip 變量的值: %d\n", *ip )
}

a 變量的地址是: 20818a220
ip 變量儲存的指針地址: 20818a220
*ip 變量的值: 20

Go 空指針

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

nil 指針也稱為空指針。

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

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

查看以下實例：

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("ptr 的值為 : %x\n", ptr  )
}
//以上實例輸出結果為：
ptr 的值為 : 0

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

Go指針更多內容

接下來我們將為大家介紹Go語言中更多的指針應用：

Go指針數組

在我們了解指針數組前，先看個實例，定義了長度為 3 的整型數組：

package main

import "fmt"

const MAX int = 3

func main() {

   a := []int{10,100,200}
   var i int

   for i = 0; i < MAX; i++ {
      fmt.Printf("a[%d] = %d\n", i, a[i] )
   }
}
//以上代碼執行輸出結果為：
a[0] = 10
a[1] = 100
a[2] = 200

有一種情況，我們可能需要保存數組，這樣我們就需要使用到指針。

以下聲明了整型指針數組：

var ptr [MAX]*int;

ptr 為整型指針數組。因此每個元素都指向了一個值。以下實例的三個整數將存儲在指針數組中：

package main

import "fmt"

const MAX int = 3

func main() {
   a := []int{10,100,200}
   var i int
   var ptr [MAX]*int;

   for  i = 0; i < MAX; i++ {
      ptr[i] = &a[i] /* 整數地址賦值給指針數組 */
   }

   for  i = 0; i < MAX; i++ {
      fmt.Printf("a[%d] = %d\n", i,*ptr[i] )
   }
}

//以上代碼執行輸出結果為：
a[0] = 10
a[1] = 100
a[2] = 200

Go 語言指向指針的指針

如果一個指針變量存放的又是另一個指針變量的地址，則稱這個指針變量為指向指針的指針變量。

當定義一個指向指針的指針變量時，第一個指針存放第二個指針的地址，第二個指針存放變量的地址：

指向指針的指針變量聲明格式如下：

var ptr **int;

以上指向指針的指針變量為整型。

訪問指向指針的指針變量值需要使用兩個 * 號，如下所示：

package main

import "fmt"

func main() {

   var a int
   var ptr *int
   var pptr **int

   a = 3000

   /* 指針 ptr 地址 */
   ptr = &a

   /* 指向指針 ptr 地址 */
   pptr = &ptr

   /* 獲取 pptr 的值 */
   fmt.Printf("變量 a = %d\n", a )
   fmt.Printf("指針變量 *ptr = %d\n", *ptr )
   fmt.Printf("指向指針的指針變量 **pptr = %d\n", **pptr)
}
//以上實例執行輸出結果為：
變量 a = 3000
指針變量 *ptr = 3000
指向指針的指針變量 **pptr = 3000

Go 語言指針作為函數參數

Go 語言允許向函數傳遞指針，只需要在函數定義的參數上設置為指針類型即可。

以下實例演示了如何向函數傳遞指針，並在函數調用後修改函數內的值，：

package main

import "fmt"

func main() {
   /* 定義局部變量 */
   var a int = 100
   var b int= 200

   fmt.Printf("交換前 a 的值 : %d\n", a )
   fmt.Printf("交換前 b 的值 : %d\n", b )

   /* 調用函數用於交換值
   * &a 指向 a 變量的地址
   * &b 指向 b 變量的地址
   */
   swap(&a, &b)
   fmt.Printf("交換後 a 的值 : %d\n", a )
   fmt.Printf("交換後 b 的值 : %d\n", b )
}

func swap(x *int, y *int) {
   var temp int
   temp = *x    /* 保存 x 地址的值 */
   *x = *y      /* 將 y 賦值給 x */
   *y = temp    /* 將 temp 賦值給 y */
}
//以上實例允許輸出結果為：
交換前 a 的值 : 100
交換前 b 的值 : 200
交換後 a 的值 : 200
交換後 b 的值 : 100

以下是一個更簡潔的變量交換實例：

package main

import "fmt"

func main() {
    /* 定義局部變量 */
   var a int = 100
   var b int= 200
   swap(&a, &b);

   fmt.Printf("交換後 a 的值 : %d\n", a )
   fmt.Printf("交換後 b 的值 : %d\n", b )
}

/* 交換函數這樣寫更加簡潔，也是 go 語言的特性，可以用下，c++ 和 c# 是不能這麽幹的 */
 
func swap(x *int, y *int){
    *x, *y = *y, *x
}

GO語言學習（十五）Go 語言指針