一、Go語言中的指針介紹

1.1 指針介紹

指針是一個存儲變量內存地址的變量。它們允許程序直接訪問和操作內存中的數(shù)據(jù)，而不是對數(shù)據(jù)的副本進行操作。以下是指針的一些關鍵概念：

• 內存地址： 每個變量在計算機內存中都有一個唯一的地址，指針存儲了這個地址。
• 指針變量： 用于存儲其他變量地址的變量稱為指針變量。
• 取地址操作符（&）： 可以使用取地址操作符&來獲取變量的地址。
• 解引用操作符（*）： 可以使用解引用操作符*來訪問指針所指向的變量的值。

Go語言中的值類型（int、float、bool、string、array、struct）都有對應的指針類型，如：*int、*int64、*string等。

1.2 基本語法

• var ptr *int: 聲明指針變量ptr,用于指向一個int類型變量的地址。
• &a: 獲取變量a的內存地址,返回一個指向該地址的指針。
• *ptr: 讀取ptr指針指向地址的值,這個操作稱為“解引用”。
• *ptr = 100: 將100賦值給ptr指向的變量。

1.3 聲明和初始化

在 Go 語言中，可以使用指針來引用任何類型的變量。指針的聲明和初始化可以通過如下語法完成：

var p *int  // 聲明一個指向 int 類型的指針 p
var str *string  // 聲明一個指向 string 類型的指針 str

初始化指針可以通過 new 函數(shù)來分配內存并返回指針的地址：

p := new(int)  // 分配一個 int 類型的內存，并將指針 p 指向該內存

示例代碼：

package main
 import "fmt"
 func main() {
     var p *int
     var str *string
     fmt.Printf("p: %v, str: %v\n", p, str) // 輸出 p: <nil>, str: <nil>
     x := 10
     p = &x // 將指針p指向變量x的地址
     fmt.Printf("p: %v\n", p)   // 輸出 p: 0xc0000100e0
     fmt.Printf("*p: %d\n", *p) // 輸出 *p: 10
     str = new(string) // 分配一個string類型的內存，并將指針str指向該內存
     fmt.Printf("str: %v\n", str)   // 輸出 str: 0xc000010120
     fmt.Printf("*str: %s\n", *str) // 輸出 *str: ""
     *str = "Hello, Go!" // 通過指針修改字符串的值
     fmt.Printf("*str: %s\n", *str) // 輸出 *str: Hello, Go!
 }

1.4 Go 指針的3個重要概念

1.4.1 指針地址（Pointer Address）

• 在Go語言中，指針地址表示指針所指向的變量或數(shù)據(jù)在內存中的位置。
• 在Go語言中，與C/C++等語言不同，您不能直接獲取指針的具體地址值，因為Go語言為了安全性和內存管理而采用了更抽象的設計。但是，您可以通過獲取變量的地址來創(chuàng)建和使用指針，而這個地址由Go語言自動管理。

1.4.2 指針類型（Pointer Type）

• Go語言的指針類型表示指針可以指向的數(shù)據(jù)類型。

1.4.3 指針取值（Pointer Dereferencing）

• 指針取值是指通過指針來訪問其所指向的內存位置上的數(shù)據(jù)。在Go語言中，要獲取指針所指向的數(shù)據(jù)的值，您需要使用解引用操作符 *。

1.5 獲取指針的地址和解引用

通過 & 操作符可以獲取變量的地址，例如：

func main() {
	a := 10
	b := &a  // 將指針 b 指向變量 a 的地址
	fmt.Printf("a:%d ptr:%p\n", a, &a) // a:10 ptr:0xc00001a078
	fmt.Printf("b:%p type:%T\n", b, b) // b:0xc00001a078 type:*int
	fmt.Println(&b)                    // 0xc00000e018
}

我們來看一下b := &a的圖示：

使用*操作符可以解引用指針，獲取指針指向的值：

fmt.Println(*b)  // 輸出指針 b 指向的值，即變量 a 的值

示例代碼：

func main() {
	//指針取值
	a := 10
	b := &a // 取變量a的地址，將指針保存到b中
	fmt.Printf("type of b:%T\n", b)
	c := *b // 指針取值（根據(jù)指針去內存取值）
	fmt.Printf("type of c:%T\n", c)
	fmt.Printf("value of c:%v\n", c)
}

輸出如下：

type of b:*int
type of c:int
value of c:10

總結： 取地址操作符&和取值操作符*是一對互補操作符，&取出地址，*根據(jù)地址取出地址指向的值。

變量、指針地址、指針變量、取地址、取值的相互關系和特性如下：

• 對變量進行取地址（&）操作，可以獲得這個變量的指針變量。
• 指針變量的值是指針地址。
• 對指針變量進行取值（*）操作，可以獲得指針變量指向的原變量的值。

1.6 傳遞指針給函數(shù)

您可以將指針作為參數(shù)傳遞給函數(shù)，從而可以在函數(shù)內部修改原始變量的值，而不是復制。這可以用于實現(xiàn)函數(shù)的副作用。

func modify1(x int) {
	x = 100
}
func modify2(x *int) {
	*x = 100
}
func main() {
	a := 10
	modify1(a)
	fmt.Println(a) // 10
	modify2(&a)
	fmt.Println(a) // 100
}

1.7 指針的比較

您可以使用==和!=運算符來比較指針。它們將比較指針是否引用相同的內存地址。

var x int = 42
var p *int  // 聲明一個整數(shù)指針
p = &x      // 將變量x的地址分配給指針p
fmt.Println(p == &x) // true，p和&x都指向相同的內存地址

1.8 指針的使用注意事項

• 謹慎使用指針，以避免懸掛指針（dangling pointers）和內存泄漏等問題。
• 在Go中，指針通常用于傳遞大型數(shù)據(jù)結構，以避免復制數(shù)據(jù)。
• Go沒有指針運算（如C/C++中的指針算術運算），因此您不能像C/C++那樣執(zhí)行指針加法和減法操作。

二、空指針和指針的零值

• **指針的零值：**如果您聲明了一個指針但沒有初始化它，它將具有零值，即nil。
• **空指針：**如果指針沒有指向任何有效的內存地址，它將具有nil值，表示空指針。在使用指針之前，通常會檢查指針是否為nil。

package main
import "fmt"
func main() {
    var p *string
    fmt.Println(p)
    fmt.Printf("p的值是%s/n", p)
    if p != nil {
        fmt.Println("非空")
    } else {
        fmt.Println("空值")
    }
}

三、指針的應用場景

3.1 傳遞大對象

在函數(shù)參數(shù)傳遞時，如果直接傳遞大對象的副本，會產生額外的內存開銷。通過傳遞指針，可以避免復制整個對象，提高程序的性能。

示例代碼：

 package main
 import "fmt"
 type BigObject struct {
     // 大對象的定義...
 }
 func processObject(obj *BigObject) {
     // 對大對象進行處理...
 }
 func main() {
     obj := BigObject{}
     processObject(&obj) // 傳遞大對象的指針
 }

3.2 指針作為函數(shù)參數(shù)和修改函數(shù)外部變量

在 Go 語言中，函數(shù)的參數(shù)傳遞默認是值傳遞。通過指針傳遞，函數(shù)可以修改函數(shù)外部的變量。這在需要修改外部變量的值時非常有用，特別是在處理復雜數(shù)據(jù)結構或需要對全局狀態(tài)進行修改的情況下。

示例代碼：

 package main
 import "fmt"
 func modifyValue(ptr *int) {
     *ptr = 30 // 修改指針指向的值
 }
 func main() {
     x := 10
     modifyValue(&x) // 傳遞x的地址給modifyValue函數(shù)
     fmt.Println(x) // 輸出修改后的x的值，即30
 }

3.3 動態(tài)分配內存

指針的另一個重要應用是動態(tài)分配內存。通過 new 函數(shù)可以在堆上動態(tài)分配內存，避免了在棧上分配固定大小的內存空間的限制。這對于需要返回動態(tài)分配的數(shù)據(jù)或創(chuàng)建復雜數(shù)據(jù)結構非常有用。

示例代碼：

 package main
 import "fmt"
 type ComplexStruct struct {
     // 復雜數(shù)據(jù)結構的定義...
 }
 func createComplexStruct() *ComplexStruct {
     cs := new(ComplexStruct) // 動態(tài)分配內存并返回指針
     // 初始化復雜數(shù)據(jù)結構...
     return cs
 }
 func main() {
     obj := createComplexStruct()
     // 對動態(tài)分配的數(shù)據(jù)結構進行操作...
 }

3.4 函數(shù)返回指針

在函數(shù)中返回指針可以將函數(shù)內部創(chuàng)建的變量的地址傳遞給調用者。這樣做可以避免復制整個變量，并允許調用者直接訪問和修改函數(shù)內部的數(shù)據(jù)。

示例代碼：

 package main
 import "fmt"
 func createValue() *int {
     x := 10 // 在函數(shù)內部創(chuàng)建變量
     return &x // 返回變量的地址
 }
 func main() {
     p := createValue()
     fmt.Println(*p) // 輸出通過指針訪問的函數(shù)內部變量的值，即10
 }

四、new和make

我們先來看一個例子：

func main() {
	var a *int
	*a = 100
	fmt.Println(*a)
	var b map[string]int
	b["測試"] = 100
	fmt.Println(b)
}

執(zhí)行上面的代碼會引發(fā)panic，為什么呢？ 在Go語言中對于引用類型的變量，我們在使用的時候不僅要聲明它，還要為它分配內存空間，否則我們的值就沒辦法存儲。而對于值類型的聲明不需要分配內存空間，是因為它們在聲明的時候已經默認分配好了內存空間。要分配內存，就引出來今天的new和make。 Go語言中new和make是內建的兩個函數(shù)，主要用來分配內存。

4.1 new

new是一個內置的函數(shù)，它的函數(shù)簽名如下：

func new(Type) *Type

其中，

• Type表示類型，new函數(shù)只接受一個參數(shù)，這個參數(shù)是一個類型
• *Type表示類型指針，new函數(shù)返回一個指向該類型內存地址的指針。

new函數(shù)不太常用，使用new函數(shù)得到的是一個類型的指針，并且該指針對應的值為該類型的零值。舉個例子：

func main() {
	a := new(int)
	b := new(bool)
	fmt.Printf("%T\n", a) // *int
	fmt.Printf("%T\n", b) // *bool
	fmt.Println(*a)       // 0
	fmt.Println(*b)       // false
}

本節(jié)開始的示例代碼中var a *int只是聲明了一個指針變量a但是沒有初始化，指針作為引用類型需要初始化后才會擁有內存空間，才可以給它賦值。應該按照如下方式使用內置的new函數(shù)對a進行初始化之后就可以正常對其賦值了：

func main() {
	var a *int
	a = new(int)
	*a = 10
	fmt.Println(*a)
}

4.2 make

make也是用于內存分配的，區(qū)別于new，它只用于slice、map以及channel的內存創(chuàng)建，而且它返回的類型就是這三個類型本身，而不是他們的指針類型，因為這三種類型就是引用類型，所以就沒有必要返回他們的指針了。make函數(shù)的函數(shù)簽名如下：

func make(t Type, size ...IntegerType) Type

make函數(shù)是無可替代的，我們在使用slice、map以及channel的時候，都需要使用make進行初始化，然后才可以對它們進行操作。這個我們在上一章中都有說明，關于channel我們會在后續(xù)的章節(jié)詳細說明。

本節(jié)開始的示例中var b map[string]int只是聲明變量b是一個map類型的變量，需要像下面的示例代碼一樣使用make函數(shù)進行初始化操作之后，才能對其進行鍵值對賦值：

func main() {
    var b map[string]int
    b = make(map[string]int, 10)
    b["測試"] = 100
    fmt.Println(b)
}

4.3 new與make的區(qū)別

• 二者都是用來做內存分配的。
• make只用于slice、map以及channel的初始化，返回的還是這三個引用類型本身；
• 而new用于類型的內存分配，并且內存對應的值為類型零值，返回的是指向類型的指針。

到此這篇關于一文介紹Go語言中的指針的文章就介紹到這了,更多相關Go 指針內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！ 

最新評論