定義

了解指針之前，先講一下什么是變量。

每當(dāng)我們編寫(xiě)任何程序時(shí)，我們都需要在內(nèi)存中存儲(chǔ)一些數(shù)據(jù)/信息。數(shù)據(jù)存儲(chǔ)在特定地址的存儲(chǔ)器中。內(nèi)存地址看起來(lái)像0xAFFFF（這是內(nèi)存地址的十六進(jìn)制表示）。

現(xiàn)在，要訪問(wèn)數(shù)據(jù)，我們需要知道存儲(chǔ)它的地址。我們可以跟蹤存儲(chǔ)與程序相關(guān)的數(shù)據(jù)的所有內(nèi)存地址。但想象一下，記住所有內(nèi)存地址并使用它們?cè)L問(wèn)數(shù)據(jù)會(huì)非常困難。這就是為什么引入變量。

變量是一種占位符，用于引用計(jì)算機(jī)的內(nèi)存地址，可理解為內(nèi)存地址的標(biāo)簽。

什么是指針

指針是存儲(chǔ)另一個(gè)變量的內(nèi)存地址的變量。所以指針也是一種變量，只不過(guò)它是一種特殊變量，它的指針存放的是另一個(gè)變量的內(nèi)存地址。

在上面的例子中，指針p包含值0x0001，該值是變量的地址a。

Go類(lèi)型占用內(nèi)存情況

unsafe包可以獲取變量的內(nèi)存使用情況

Go語(yǔ)言提供以下基本數(shù)字類(lèi)型：

無(wú)符號(hào)整數(shù) uint8，uint16，uint32，uint64

符號(hào)整數(shù) int8，int16，int32，int64

實(shí)數(shù) float32，float64 Predeclared

整數(shù)(依賴系統(tǒng)類(lèi)型，跟系統(tǒng)有關(guān)) uint，int，uintptr （指針）

32位系統(tǒng)

uint=uint32 int=int32 uintptr為32位的指針

64位系統(tǒng)

uint=uint64 int=int64 uintptr為64位的指針

示例：

package mainimport ( "fmt" "unsafe")func main() { var uint8Value uint8 var uint16Value uint16 var uint32Value uint32 var uint64Value uint64 var int8Value int8 var int16Value int16 var int32Value int32 var int64Value int64 var float32Value float32 var float64Value float64 fmt.Println("uint8Value = Size:", unsafe.Sizeof(uint8Value)) //uint8Value = Size: 1 fmt.Println("uint16Value = Size:", unsafe.Sizeof(uint16Value)) //uint16Value = Size: 2 fmt.Println("uint32Value = Size:", unsafe.Sizeof(uint32Value)) //uint32Value = Size: 4 fmt.Println("uint64Value = Size:", unsafe.Sizeof(uint64Value))// uint64Value = Size: 8 fmt.Println("int8Value = Size:", unsafe.Sizeof(int8Value)) //int8Value = Size: 1 fmt.Println("int16Value = Size:", unsafe.Sizeof(int16Value))//int16Value = Size: 2 fmt.Println("int32Value = Size:", unsafe.Sizeof(int32Value))//int32Value = Size: 4 fmt.Println("int64Value = Size:", unsafe.Sizeof(int64Value)) //int64Value = Size: 8 fmt.Println("float32Value = Size:", unsafe.Sizeof(float32Value)) //float32Value = Size: 4 fmt.Println("float64Value = Size:", unsafe.Sizeof(float64Value))//float64Value = Size: 8}

上面的是基本類(lèi)型，接下來(lái)了解下復(fù)雜類(lèi)型，以結(jié)構(gòu)體類(lèi)型為例

type Example struct { BoolValue bool IntValue int16 FloatValue float32}

該結(jié)構(gòu)代表復(fù)雜類(lèi)型。它代表7個(gè)字節(jié)，帶有三個(gè)不同的數(shù)字表示。bool是一個(gè)字節(jié)，int16是2個(gè)字節(jié)，float32增加4個(gè)字節(jié)。但是，在此結(jié)構(gòu)的內(nèi)存中實(shí)際分配了8個(gè)字節(jié)。

所有內(nèi)存都分配在對(duì)齊邊界上，以最大限度地減少內(nèi)存碎片的整理。要確定對(duì)齊邊界Go用于您的體系結(jié)構(gòu)，您可以運(yùn)行unsafe.Alignof函數(shù)。Go為64bit Darwin平臺(tái)的對(duì)齊邊界是8個(gè)字節(jié)。因此，當(dāng)Go確定結(jié)構(gòu)的內(nèi)存分配時(shí)，它將填充字節(jié)以確保最終內(nèi)存占用量是8的倍數(shù)。編譯器將確定添加填充的位置。

什么是內(nèi)存對(duì)齊呢？

內(nèi)存對(duì)齊，也叫邊界對(duì)齊（boundary alignment)，是處理器為了提高處理性能而對(duì)存取數(shù)據(jù)的起始地址所提出的一種要求。編譯器為了使我們編寫(xiě)的C程序更有效，就必須最大限度地滿足處理器對(duì)邊界對(duì)齊的要求。

從處理器的角度來(lái)看，需要盡可能減少對(duì)內(nèi)存的訪問(wèn)次數(shù)以實(shí)現(xiàn)對(duì)數(shù)據(jù)結(jié)構(gòu)進(jìn)行更加高效的操作。為什么呢？因?yàn)楸M管處理器包含了緩存，但它在處理數(shù)據(jù)時(shí)還得讀取緩存中的數(shù)據(jù)，讀取緩存的次數(shù)當(dāng)然是越少越好！如上圖所示，在采用邊界對(duì)齊的情況下，當(dāng)處理器需要訪問(wèn)a變量和b變量時(shí)都只需進(jìn)行一次存取（圖中花括號(hào)表示一次存取操作）。若不采用邊界對(duì)齊，a變量只要一次處理器操作，而b變量卻至少要進(jìn)行兩次操作。對(duì)于b_,處理器還得調(diào)用更多指令將其合成一個(gè)完整的4字節(jié)，這樣無(wú)疑大大降低了程序效率。

以下程序顯示Go插入到Example類(lèi)型struct的內(nèi)存占用中的填充：

package mainimport ( "fmt" "unsafe")type Example struct { BoolValue bool IntValue int16 FloatValue float32}func main() { example := &Example{ BoolValue: true, IntValue: 10, FloatValue: 3.141592, } exampleNext := &Example{ BoolValue: true, IntValue: 10, FloatValue: 3.141592, } alignmentBoundary := unsafe.Alignof(example) sizeBool := unsafe.Sizeof(example.BoolValue) offsetBool := unsafe.Offsetof(example.BoolValue) sizeInt := unsafe.Sizeof(example.IntValue) offsetInt := unsafe.Offsetof(example.IntValue) sizeFloat := unsafe.Sizeof(example.FloatValue) offsetFloat := unsafe.Offsetof(example.FloatValue) sizeBoolNext := unsafe.Sizeof(exampleNext.BoolValue) offsetBoolNext := unsafe.Offsetof(exampleNext.BoolValue) fmt.Printf("example Size: %d\n", unsafe.Sizeof(example)) fmt.Printf("Alignment Boundary: %d\n", alignmentBoundary) fmt.Printf("BoolValue = Size: %d Offset: %d Addr: %v\n", sizeBool, offsetBool, &example.BoolValue) fmt.Printf("IntValue = Size: %d Offset: %d Addr: %v\n", sizeInt, offsetInt, &example.IntValue) fmt.Printf("FloatValue = Size: %d Offset: %d Addr: %v\n", sizeFloat, offsetFloat, &example.FloatValue) fmt.Printf("Next = Size: %d Offset: %d Addr: %v\n", sizeBoolNext, offsetBoolNext, &exampleNext.BoolValue)}

輸出：

example Size: 8 Alignment Boundary: 8 BoolValue = Size: 1 Offset: 0 Addr: 0xc00004c080 IntValue = Size: 2 Offset: 2 Addr: 0xc00004c082 FloatValue = Size: 4 Offset: 4 Addr: 0xc00004c084 Next = Size: 1 Offset: 0 Addr: 0xc00004c088

類(lèi)型結(jié)構(gòu)的對(duì)齊邊界是預(yù)期的8個(gè)字節(jié)。

大小值顯示將讀取和寫(xiě)入該字段的內(nèi)存量。正如所料，大小與類(lèi)型信息一致。

偏移值顯示進(jìn)入內(nèi)存占用的字節(jié)數(shù)，我們將找到該字段的開(kāi)頭。

地址是可以找到內(nèi)存占用內(nèi)每個(gè)字段的開(kāi)頭的地方。

我們可以看到Go在BoolValue和IntValue字段之間填充1個(gè)字節(jié)。偏移值和兩個(gè)地址之間的差異是2個(gè)字節(jié)。您還可以看到下一個(gè)內(nèi)存分配是從結(jié)構(gòu)中的最后一個(gè)字段開(kāi)始的4個(gè)字節(jié)。

指針的使用

聲明一個(gè)指針

使用以下語(yǔ)法聲明類(lèi)型為T(mén)的指針

var p *int

指針的零值是nil。這意味著任何未初始化的指針都將具有該值nil。讓我們看一個(gè)完整的例子

package mainimport "fmt"func main() { var p *int &p=1}

注意：當(dāng)指針沒(méi)有指向的時(shí)候，不能對(duì)(*point)進(jìn)行操作包括讀取，否則會(huì)報(bào)空指針異常。

示例：

package mainfunc main() { var p *int *p = 1 //panic: runtime error: invalid memory address or nil pointer dereference}

解決方法就是給該指針?lè)峙湟粋€(gè)指向,即初始化一個(gè)內(nèi)存，并把該內(nèi)存地址賦予指針變量

示例：

import "fmt"func main() { var p *int var m int p = &m *p = 1 fmt.Println("m=", m) fmt.Println("p=", p)}

或還可以使用內(nèi)置new()函數(shù)創(chuàng)建指針。該new()函數(shù)將類(lèi)型作為參數(shù)，分配足夠的內(nèi)存以容納該類(lèi)型的值，并返回指向它的指針。

import "fmt"func main() { var p *int p = new(int) *p = 1 fmt.Println("p=", *p)}

初始化指針

您可以使用另一個(gè)變量的內(nèi)存地址初始化指針。可以使用&運(yùn)算符檢索變量的地址

var x = 100var p *int = &x

注意我們?nèi)绾问褂?amp;帶變量的運(yùn)算符x來(lái)獲取其地址，然后將地址分配給指針p。

就像Golang中的任何其他變量一樣，指針變量的類(lèi)型也由編譯器推斷。所以你可以省略p上面例子中指針的類(lèi)型聲明，并像這樣寫(xiě)

var p = &a

取消引用指針

您可以*在指針上使用運(yùn)算符來(lái)訪問(wèn)存儲(chǔ)在指針?biāo)赶虻淖兞恐械闹怠＿@被稱(chēng)為解除引用或間接

package mainimport "fmt"func main() { var a = 100 var p = &a fmt.Println("a = ", a) fmt.Println("p = ", p) fmt.Println("*p = ", *p)}

輸出：

a = 100p = 0xc00004c080*p = 100

您不僅可以使用*運(yùn)算符訪問(wèn)指向變量的值，還可以更改它。以下示例a通過(guò)指針設(shè)置存儲(chǔ)在變量中的值p

package mainimport "fmt"func main() { var a = 1000 var p = &a fmt.Println("a (before) = ", a) // Changing the value stored in the pointed variable through the pointer *p = 2000 fmt.Println("a (after) = ", a)}

輸出：

a (before) = 1000a (after) = 2000

指針指向指針

指針可以指向任何類(lèi)型的變量。它也可以指向另一個(gè)指針。以下示例顯示如何創(chuàng)建指向另一個(gè)指針的指針

package mainimport "fmt"func main() { var a = 7.98 var p = &a var pp = &p fmt.Println("a = ", a) fmt.Println("address of a = ", &a) fmt.Println("p = ", p) fmt.Println("address of p = ", &p) fmt.Println("pp = ", pp) // Dereferencing a pointer to pointer fmt.Println("*pp = ", *pp) fmt.Println("**pp = ", **pp)}

Go中沒(méi)有指針?biāo)阈g(shù)

如果您使用過(guò)C / C ++，那么您必須意識(shí)到這些語(yǔ)言支持指針?biāo)惴ā＠纾梢赃f增/遞減指針以移動(dòng)到下一個(gè)/上一個(gè)內(nèi)存地址。您可以向/從指針添加或減去整數(shù)值。您也可以使用關(guān)系運(yùn)算符比較兩個(gè)三分球==，<，>等。

但Go不支持對(duì)指針進(jìn)行此類(lèi)算術(shù)運(yùn)算。任何此類(lèi)操作都將導(dǎo)致編譯時(shí)錯(cuò)誤

package mainfunc main() { var x = 67 var p = &x var p1 = p + 1 // Compiler Error: invalid operation}

但是，您可以使用==運(yùn)算符比較相同類(lèi)型的兩個(gè)指針的相等性。

package mainimport "fmt"func main() { var a = 75 var p1 = &a var p2 = &a if p1 == p2 { fmt.Println("Both pointers p1 and p2 point to the same variable.") }}

Go中傳遞簡(jiǎn)單類(lèi)型

import "fmt"func main() { p := 5 change(&p) fmt.Println("p=", p)//p= 0}func change(p *int) { *p = 0}

Go中所有的都是按值傳遞，對(duì)于復(fù)雜類(lèi)型，傳的是指針的拷貝

package mainimport "fmt"func main() { var m map[string]int m = map[string]int{"one": 1, "two": 2} n := m fmt.Printf("%p\n", &m) //0xc000074018 fmt.Printf("%p\n", &n) //0xc000074020 fmt.Println(m) // map[two:2 one:1] fmt.Println(n) //map[one:1 two:2] changeMap(m) fmt.Printf("%p\n", &m) //0xc000074018 fmt.Printf("%p\n", &n) //0xc000074020 fmt.Println(m) //map[one:1 two:2 three:3] fmt.Println(n) //map[one:1 two:2 three:3]}func changeMap(m map[string]int) { m["three"] = 3 fmt.Printf("changeMap func %p\n", m) //changeMap func 0xc000060240}

直接傳指針 也是傳指針的拷貝

package mainimport "fmt"func main() { var m map[string]int m = map[string]int{"one": 1, "two": 2} n := m fmt.Printf("%p\n", &m) //0xc000074018 fmt.Printf("%p\n", &n) //0xc000074020 fmt.Println(m) // map[two:2 one:1] fmt.Println(n) //map[one:1 two:2] changeMap(&m) fmt.Printf("%p\n", &m) //0xc000074018 fmt.Printf("%p\n", &n) //0xc000074020 fmt.Println(m) //map[one:1 two:2 three:3] fmt.Println(n) //map[two:2 three:3 one:1]}func changeMap(m *map[string]int) { //m["three"] = 3 //這種方式會(huì)報(bào)錯(cuò) invalid operation: m["three"] (type *map[string]int does not support indexing) (*m)["three"] = 3 //正確 fmt.Printf("changeMap func %p\n", m) //changeMap func 0x0}

總結(jié)：

• Go 不能進(jìn)行指針運(yùn)算。
• 指針傳遞是很廉價(jià)的，只占用 4 個(gè)或 8 個(gè)字節(jié)。當(dāng)程序在工作中需要占用大量的內(nèi)存，或很多變量，或者兩者都有，使用指針會(huì)減少內(nèi)存占用和提高效率。
• 指針也是一種類(lèi)型，不同于一般類(lèi)型，指針的值是地址，這個(gè)地址指向其他的內(nèi)存，通過(guò)指針可以讀取其所指向的地址所存儲(chǔ)的值。
• 函數(shù)方法的接受者，也可以是指針變量。簡(jiǎn)單類(lèi)型和復(fù)雜類(lèi)型在傳遞的時(shí)候不同，復(fù)雜類(lèi)型傳值或傳指針都是指針拷貝。
• 只聲明未賦值的變量，golang都會(huì)自動(dòng)為其初始化為零值，基礎(chǔ)數(shù)據(jù)類(lèi)型的零值比較簡(jiǎn)單，引用類(lèi)型和指針的零值都為nil，nil類(lèi)型不能直接賦值，因此需要通過(guò)new開(kāi)辟一個(gè)內(nèi)存，或指向一個(gè)變量。

總結(jié)

以上是生活随笔為你收集整理的指针和内存分配结构体指针分配内存的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。