一、指標

1.1 指標的概念

指標是儲存另一個變數的記憶體地址的變數。

我們都知道，變數是一種使用方便的佔位符，用於引用計算機記憶體地址。

一個指標變數可以指向任何一個值的記憶體地址它指向那個值的記憶體地址。

在上面的圖中，變數b的值為156，儲存在記憶體地址0x1040a124。變數a持有b的地址，現在a被認為指向b。

1.2 獲取變數的地址

Go 語言的取地址符是 &，放到一個變數前使用就會返回相應變數的記憶體地址。

package main

import "fmt"

func main() {
   var a int = 10   

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

執行結果：

變數的地址: 20818a220

1.3 宣告指標

宣告指標，*T是指標變數的型別，它指向T型別的值。

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

示例程式碼：

package main

import "fmt"

type name int8
type first struct {
	a int
	b bool
	name
}

func main() {
	a := new(first)
	a.a = 1
	a.name = 11
	fmt.Println(a.b, a.a, a.name)
}

執行結果：

false 1 11

未初始化的變數自動賦上初始值

package main

import "fmt"

type name int8
type first struct {
	a int
	b bool
	name
}

func main() {
	var a = first{1, false, 2}
	var b *first = &a
	fmt.Println(a.b, a.a, a.name, &a, b.a, &b, (*b).a)
}

執行結果：

false 1 2 &{1 false 2} 1 0xc042068018 1

獲取指標地址在指標變數前加&的方式

1.4 空指標

Go 空指標
當一個指標被定義後沒有分配到任何變數時，它的值為 nil。
nil 指標也稱為空指標。
nil在概念上和其它語言的null、None、nil、NULL一樣，都指代零值或空值。
一個指標變數通常縮寫為 ptr。

空指標判斷：

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

1.5 獲取指標的值

獲取一個指標意味著訪問指標指向的變數的值。語法是：*a

示例程式碼：

package main  
import (  
    "fmt"
)

func main() {  
    b := 255
    a := &b
    fmt.Println("address of b is", a)
    fmt.Println("value of b is", *a)
}

1.6 操作指標改變變數的數值

示例程式碼：

package main

import (  
    "fmt"
)

func main() {  
    b := 255
    a := &b
    fmt.Println("address of b is", a)
    fmt.Println("value of b is", *a)
    *a++
    fmt.Println("new value of b is", b)
}

執行結果

address of b is 0x1040a124  
value of b is 255  
new value of b is 256  

1.7 使用指標傳遞函式的引數

示例程式碼

package main

import (  
    "fmt"
)

func change(val *int) {  
    *val = 55
}
func main() {  
    a := 58
    fmt.Println("value of a before function call is",a)
    b := &a
    change(b)
    fmt.Println("value of a after function call is", a)
}

執行結果

value of a before function call is 58  
value of a after function call is 55  

不要將一個指向陣列的指標傳遞給函式。使用切片。

假設我們想對函式內的陣列進行一些修改，並且對呼叫者可以看到函式內的陣列所做的更改。一種方法是將一個指向陣列的指標傳遞給函式。

package main

import (  
    "fmt"
)

func modify(arr *[3]int) {  
    (*arr)[0] = 90
}

func main() {  
    a := [3]int{89, 90, 91}
    modify(&a)
    fmt.Println(a)
}

執行結果

[90 90 91]

示例程式碼：

package main

import (  
    "fmt"
)

func modify(arr *[3]int) {  
    arr[0] = 90
}

func main() {  
    a := [3]int{89, 90, 91}
    modify(&a)
    fmt.Println(a)
}

執行結果

[90 90 91]

雖然將指標傳遞給一個數組作為函式的引數並對其進行修改，但這並不是實現這一目標的慣用方法。我們有切片。

示例程式碼：

package main

import (  
    "fmt"
)

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

func main() {  
    a := [3]int{89, 90, 91}
    modify(a[:])
    fmt.Println(a)
}

執行結果：

[90 90 91]

Go不支援指標演算法。

package main

func main() {
b := […]int{109, 110, 111}
p := &b
p++
}

nvalid operation: p++ (non-numeric type *[3]int)

指標陣列

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

有一種情況，我們可能需要儲存陣列，這樣我們就需要使用到指標。

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

1.8 指標的指標

指標的指標

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

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

指標作為函式引數

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