Go語言指針使用分析與講解

更新時間：2021年07月29日 09:07:42 作者：極客江南

這篇文章主要介紹了Go語言指針使用分析與講解,本篇文章通過簡要的案例,講解了該項技術(shù)的了解與使用,以下就是詳細(xì)內(nèi)容,需要的朋友可以參考下

普通指針

和C語言一樣, 允許用一個變量來存放其它變量的地址, 這種專門用于存儲其它變量地址的變量, 我們稱之為指針變量
和C語言一樣, Go語言中的指針無論是什么類型占用內(nèi)存都一樣(32位4個字節(jié), 64位8個字節(jié))

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語言一樣, 只要一個指針變量保存了另一個變量對應(yīng)的內(nèi)存地址, 那么就可以通過*來訪問指針變量指向的存儲空間

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
}

指向數(shù)組指針

在C語言中, 數(shù)組名,&數(shù)組名,&數(shù)組首元素保存的都是同一個地址

#include <stdio.h>

int main(){
     int arr[3] = {1, 3, 5};
     printf("%p\n", arr); // 0060FEA4
     printf("%p\n", &arr); // 0060FEA4
     printf("%p\n", &arr[0]); // 0060FEA4
}

在Go語言中通過數(shù)組名無法直接獲取數(shù)組的內(nèi)存地址

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
}

在C語言中, 無論我們將數(shù)組名,&數(shù)組名,&數(shù)組首元素賦值給指針變量, 都代表指針變量指向了這個數(shù)組

#include <stdio.h>

int main(){
     int arr[3] = {1, 3, 5};
     int *p1 = arr;
     p1[1] = 6;
     printf("%d\n", arr[1]);

     int *p2 = &arr;
     p2[1] = 7;
     printf("%d\n", arr[1]);

     int *p3 = &arr[0];
     p3[1] = 8;
     printf("%d\n", arr[1]);
}

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

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]
	// 指針指向數(shù)組之后操作數(shù)組的幾種方式
	// 1.直接通過數(shù)組名操作
	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])
}

指向切片的指針

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

package main

import "fmt"

func main() {
	// 1.定義一個切片
	var sce[]int = []int{1, 3, 5}
	// 2.打印切片的地址
	// 切片變量中保存的地址, 也就是指向的那個數(shù)組的地址 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打印出來的是切片變量保存的地址, 也就是數(shù)組的地址 *p = 0xc0420620a0
	fmt.Printf("*p = %p\n", *p)
	fmt.Println(*p) // [1 3 5]
	
	// 5.修改切片的值
	// 通過*p找到切片變量指向的存儲空間(數(shù)組), 然后修改數(shù)組中保存的數(shù)據(jù)
	(*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)
}

指向結(jié)構(gòu)體指針

Go語言中指向結(jié)構(gòu)體的指針和C語言一樣
結(jié)構(gòu)體和指針
- 創(chuàng)建結(jié)構(gòu)體指針變量有兩種方式

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

  // 通過new內(nèi)置函數(shù)傳入數(shù)據(jù)類型創(chuàng)建
  // 內(nèi)部會創(chuàng)建一個空的結(jié)構(gòu)體變量, 然后返回這個結(jié)構(gòu)體變量的地址
  var p2 = new(Student)
  fmt.Println(p2) // &{ 0}
}

利用結(jié)構(gòu)體指針操作結(jié)構(gòu)體屬性

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

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