Golang語言基礎教程：指針初識

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