Go 語言什麼時候該使用指針？指針使用的分析與講解

什麼是指針
我們都知道，程序運行時的數據是存放在內存中的，每一個存儲在內存中的數據都有一個編號，這個編號就是內存地址。我們可以根據這個內存地址來找到內存中存儲的數據，而內存地址可以被賦值給一個指針。我們也可以簡單的理解爲指針就是內存地址。

指針的聲明和定義
在 Go 語言中，獲取一個指針，直接使用取地址符 & 就可以。
示例：

func main() {
  name := "Go語言圈"
  nameP := &name //取地址
  fmt.Println("name變量值爲：", name)
  fmt.Println("name變量的內存地址爲：", nameP)
}
//運行結果：
//name變量值爲：Go語言圈
//name變量的內存地址爲： 0xc00004e240

nameP 指針的類型是 _string Go 語言中，_類型名錶示一個對應的指針類型

從上面表格可以看到：

普通變量 name 的值是 Go 語言圈，存放在內存地址爲 0xc00004e240 的內存中
指針變量 namep 的值是普通變量的內存地址 0xc00004e240
指針變量 nameP 的值存放在內存地址爲 0xc00004e360 的內存中
普通變量存的是數據，指針變量存的是數據的地址

var 關鍵字聲明
我們也可以使用 var 關鍵字聲明

var nameP *string
nameP = &name

new 函數聲明

nameP := new(string)
nameP = &name

可以傳遞類型給這個內置的 new 函數，它會返回對應的指針類型。

指針的操作
這裏強調一下：

指針變量是一個變量，這個變量的值是指針（內存地址）！
指針變量是一個變量，這個變量的值是指針（內存地址）！
指針變量是一個變量，這個變量的值是指針（內存地址）！

獲取指針指向的值：
只需要在指針變量錢加 * 號即可獲得指針變量值所對應的數據：

nameV := *nameP
fmt.Println("nameP指針指向的值爲:",nameV) //nameP指針指向的值爲: Go語言圈

修改指針指向的值：

*nameP = "公衆號:Go語言圈" //修改指針指向的值
fmt.Println("nameP指針指向的值爲:",*nameP)
fmt.Println("name變量的值爲:",name)
//運行結果：
//nameP指針指向的值爲: 公衆號:Go語言圈
//name變量的值爲: 公衆號:Go語言圈

我們發現 nameP 指針指向的值被改變了，變量 name 的值也被改變了
因爲變量 name 存儲數據的內存就是指針 nameP 指向的內存，這塊內存被 nameP 修改後，變量 name 的值也被修改了。

通過 var 關鍵字直接定義的指針變量是不能進行賦值操作的，因爲它的值爲 nil，也就是還沒有指向的內存地址

//錯誤示例
var intP *int
*intP = 10  //錯誤，應該先給分配一塊內存，內存地址作爲變量 intP 的值，這個內存就可以存放 10 了。

//應該使用
var intP *int  //聲明int類型的指針變量 intP
intP = new(int) // 給指針分配一塊內存
*intP = 66 
fmt.Println(":::",intP)  //::: 0xc0000ac088
fmt.Println(*intP) //66
//簡短寫法
var intP := new(int)
*intP=66

指針參數
當給一個函數使用指針作爲參數的時候，就可以在函數中，通過形參改變實參的值：

func main() {
    name := "瘋子"
    modify(&name)
    fmt.Println("name的值爲:",name)
}
func modify(name *string)  {
    *name = "wucs"
}
//運行結果：
//name的值爲: wucs

指針接收者

如果接收者類型是 map、slice、channel 這類引用類型，不使用指針；
如果需要修改接收者，那麼需要使用指針；
如果接收者是比較大的類型，可以考慮使用指針，因爲內存拷貝廉價，所以效率高。

普通指針
和 C 語言一樣, 允許用一個變量來存放其它變量的地址, 這種專門用於存儲其它變量地址的變量, 我們稱之爲指針變量.

和 C 語言一樣, Go 語言中的指針無論是什麼類型佔用內存都一樣 (32 位 4 個字節, 64 位 8 個字節)

package main

import (
    "fmt"
    "unsafe"
)

func main() {

    var p1 *int;
    var p2 *float64;
    var p3 *bool;
    fmt.Println(unsafe.Sizeof(p1)) // 8
    fmt.Println(unsafe.Sizeof(p2)) // 8
    fmt.Println(unsafe.Sizeof(p3)) // 8
}

和 C 語言一樣, 只要一個指針變量保存了另一個變量對應的內存地址, 那麼就可以通過 * 來訪問指針變量指向的存儲空間

package main

import (
    "fmt"
)

func main() {

    // 1.定義一個普通變量
    var num int = 666
    // 2.定義一個指針變量
    var p *int = &num
    fmt.Printf("%p\n", &num) // 0xc042064080
    fmt.Printf("%p\n", p) // 0xc042064080
    fmt.Printf("%T\n", p) // *int
    // 3.通過指針變量操作指向的存儲空間
    *p = 888
    // 4.指針變量操作的就是指向變量的存儲空間
    fmt.Println(num) // 888
    fmt.Println(*p) // 888
}

指向數組指針
在 Go 語言中通過數組名無法直接獲取數組的內存地址

package main
import "fmt"

func main() {
    var arr [3]int = [3]int{1, 3, 5}
    fmt.Printf("%p\n", arr) // 亂七八糟東西
    fmt.Printf("%p\n", &arr) // 0xc0420620a0
    fmt.Printf("%p\n", &arr[0]) // 0xc0420620a0
}

在 Go 語言中, 因爲只有數據類型一模一樣才能賦值, 所以只能通過 & 數組名賦值給指針變量, 才代表指針變量指向了這個數組

package main

import "fmt"

func main() {
    // 1.錯誤, 在Go語言中必須類型一模一樣才能賦值
    // arr類型是[3]int, p1的類型是*[3]int
    var p1 *[3]int
    fmt.Printf("%T\n", arr)
    fmt.Printf("%T\n", p1)
    p1 = arr // 報錯
    p1[1] = 6
    fmt.Println(arr[1])

    // 2.正確, &arr的類型是*[3]int, p2的類型也是*[3]int
    var p2 *[3]int
    fmt.Printf("%T\n", &arr)
    fmt.Printf("%T\n", p2)
    p2 = &arr
    p2[1] = 6
    fmt.Println(arr[1])

    // 3.錯誤, &arr[0]的類型是*int, p3的類型也是*[3]int
    var p3 *[3]int
    fmt.Printf("%T\n", &arr[0])
    fmt.Printf("%T\n", p3)
    p3 = &arr[0] // 報錯
    p3[1] = 6
    fmt.Println(arr[1])
}

注意點:
Go 語言中的指針, 不支持 C 語言中的 + 1 -1 和 ++ – 操作

package main

import "fmt"

func main() {


    var arr [3]int = [3]int{1, 3, 5}
    var p *[3]int
    p = &arr
    fmt.Printf("%p\n", &arr) // 0xc0420620a0
    fmt.Printf("%p\n", p) // 0xc0420620a0
    fmt.Println(&arr) // &[1 3 5]
    fmt.Println(p) // &[1 3 5]
    // 指針指向數組之後操作數組的幾種方式
    // 1.直接通過數組名操作
    arr[1] = 6
    fmt.Println(arr[1])
    // 2.通過指針間接操作
    (*p)[1] = 7
    fmt.Println((*p)[1])
    fmt.Println(arr[1])
    // 3.通過指針間接操作
    p[1] = 8
    fmt.Println(p[1])
    fmt.Println(arr[1])

    // 注意點: Go語言中的指針, 不支持+1 -1和++ --操作
    *(p + 1) = 9 // 報錯
    fmt.Println(*p++) // 報錯
    fmt.Println(arr[1])
}

指向切片的指針
值得注意點的是切片的本質就是一個指針指向數組, 所以指向切片的指針是一個二級指針

package main

import "fmt"

func main() {
    // 1.定義一個切片
    var sce[]int = []int{1, 3, 5}
    // 2.打印切片的地址
    // 切片變量中保存的地址, 也就是指向的那個數組的地址 sce = 0xc0420620a0
    fmt.Printf("sce = %p\n",sce )
    fmt.Println(sce) // [1 3 5]
    // 切片變量自己的地址, &sce = 0xc04205e3e0
    fmt.Printf("&sce = %p\n",&sce )
    fmt.Println(&sce) // &[1 3 5]
    // 3.定義一個指向切片的指針
    var p *[]int
    // 因爲必須類型一致才能賦值, 所以將切片變量自己的地址給了指針
    p = &sce
    // 4.打印指針保存的地址
    // 直接打印p打印出來的是保存的切片變量的地址 p = 0xc04205e3e0
    fmt.Printf("p = %p\n", p)
    fmt.Println(p) // &[1 3 5]
    // 打印*p打印出來的是切片變量保存的地址, 也就是數組的地址 *p = 0xc0420620a0
    fmt.Printf("*p = %p\n", *p)
    fmt.Println(*p) // [1 3 5]

    // 5.修改切片的值
    // 通過*p找到切片變量指向的存儲空間(數組), 然後修改數組中保存的數據
    (*p)[1] = 666
    fmt.Println(sce[1])
}

指向字典指針
與普通指針並無差異

package main
import "fmt"
func main() {

    var dict map[string]string = map[string]string{"name":"lnj", "age":"33"}
    var p *map[string]string = &dict
    (*p)["name"] = "zs"
    fmt.Println(dict)
}

指向結構體指針
Go 語言中指向結構體的指針和 C 語言一樣
結構體和指針
創建結構體指針變量有兩種方式

package main
import "fmt"
type Student struct {
    name string
    age int
}
func main() {
  // 創建時利用取地址符號獲取結構體變量地址
  var p1 = &Student{"lnj", 33}
  fmt.Println(p1) // &{lnj 33}

  // 通過new內置函數傳入數據類型創建
  // 內部會創建一個空的結構體變量, 然後返回這個結構體變量的地址
  var p2 = new(Student)
  fmt.Println(p2) // &{ 0}
}

利用結構體指針操作結構體屬性

package main
import "fmt"
type Student struct {
    name string
    age int
}
func main() {
  var p = &Student{}
  // 方式一: 傳統方式操作
  // 修改結構體中某個屬性對應的值
  // 注意: 由於.運算符優先級比*高, 所以一定要加上()
  (*p).name = "lnj"
  // 獲取結構體中某個屬性對應的值
  fmt.Println((*p).name) // lnj

  // 方式二: 通過Go語法糖操作
  // Go語言作者爲了程序員使用起來更加方便, 在操作指向結構體的指針時可以像操作接頭體變量一樣通過.來操作
  // 編譯時底層會自動轉發爲(*p).age方式
  p.age = 33
  fmt.Println(p.age) // 33
}

什麼情況下使用指針

不要對 map、slice、channel 這類引用類型使用指針；
如果需要修改方法接收者內部的數據或者狀態時，需要使用指針；
如果需要修改參數的值或者內部數據時，也需要使用指針類型的參數；
如果是比較大的結構體，每次參數傳遞或者調用方法都要內存拷貝，內存佔用多，這時候可以考慮使用指針；
像 int、bool 這樣的小數據類型沒必要使用指針；
如果需要併發安全，則儘可能地不要使用指針，使用指針一定要保證併發安全；
指針最好不要嵌套，也就是不要使用一個指向指針的指針，雖然 Go 語言允許這麼做，但是這會使你的代碼變得異常複雜。

文章鏈接：https://www.jb51.net/article/233949.htm

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/84greWs676hZfV590FeJuQ

文章鏈接：https://www.jb51.net/article/233949.htm

猜你喜歡