Go語言什麼時候該使用指標 與 指標使用分析
最近在學習Golang，所以將學習過程記為筆記，以後翻閱的時候也方便，順便也給大家做一點分享，希望能堅持下去。
學習與交流：Go語言技術交流微信群
現在就開始你的Go語言學習之旅吧！人生苦短，let’s 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
更多相關Go語言的技術文章或影片教程，請關注本公眾號獲取並檢視，感謝你的支援與信任！