go語言結構體指針操作的方法

本篇內容介紹了“go語言結構體指針操作的方法”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

指針

指針是代表某個內存地址的值。內存地址儲存另一個變量的值。

指針（地址），一旦定義了不可改變，指針指向的值可以改變

go指針操作

1.默認值nil,沒有NULL常量

2.操作符“&”取變量地址，“*“通過指針（地址）訪問目標對象（指向值）

3.不支持指針運算，不支持“->”（箭頭）運算符，直接用“.”訪問目標成員

例子1:

package main //必須有個main包
import "fmt"
func main() {
	var a int = 10
	//每個變量有2層含義：變量的內存，變量的地址
	fmt.Printf("a = %d\n", a) //變量的內存
	fmt.Printf("&a = %d\n", &a)
	//保存某個變量的地址，需要指針類型   *int 保存int的地址， **int 保存 *int 地址
	//聲明(定義)， 定義只是特殊的聲明
	//定義一個變量p, 類型為*int
	var p *int
	p = &a //指針變量指向誰，就把誰的地址賦值給指針變量
	fmt.Printf("p = %v, &a = %v\n", p, &a)
	*p = 666 //*p操作的不是p的內存，是p所指向的內存(就是a)
	fmt.Printf("*p = %v, a = %v\n", *p, a)

}

例子2:

package main
import "fmt"
func main() {
	a := 10
	b := &a
	*b = 11111  //操作指向a的值
	fmt.Println(a)  //11111
}

不能操作不合法指向

package main //必須有個main包
import "fmt"
func main() {
	var p *int
	p = nil
	fmt.Println("p = ", p)
	//*p = 666 //err, 因為p沒有合法指向
	var a int
	p = &a //p指向a
	*p = 666
	fmt.Println("a = ", a)

}

new函數

表達式new(int)將創建一個int類型的匿名變量,為int類型的新值分配并清零一塊內存空間，然后將這塊內存空間的地址作為結果返回，而這個結果就是指向這個新的int類型值的指針值，返回的指針類型為*int

package main
import "fmt"
func main() {
	//var a *int
	a := new(int)  // a為*int類型，指向匿名的int變量
	fmt.Println(*a)  // 0
	b := new(int)  // b為*int類型，指向匿名的int變量
	*b = 2
	fmt.Println(*b) // 2
}

我們只需要使用new()函數，無需擔心內存的生命周期，和回收刪除。因為GO語言的（gc）內存管理系統會幫我們處理。

指針做函數的參數

例子1:交換值,普通變量做函數參數。內部交換成功，外部失敗

package main //必須有個main包
import "fmt"
func swap(a, b int) {
	a, b = b, a
	fmt.Printf("swap: a = %d, b = %d\n", a, b)  //swap: a = 20, b = 10
}
func main() {
	a, b := 10, 20
	//通過一個函數交換a和b的內容
	swap(a, b) //變量本身傳遞，值傳遞（站在變量角度）
	fmt.Printf("main: a = %d, b = %d\n", a, b)  //main: a = 10, b = 20
}

例子2:指針傳參，內部外部都交換成功

package main //必須有個main包
import (
	"fmt"
)
func test(a, b *int) {
	*a, *b = *b, *a
	fmt.Printf("swap: a = %d, b = %d\n", *a, *b)
}
func main() {
	a, b := 10, 20
	////通過一個函數交換a和b的內容
	test(&a, &b)
	fmt.Printf("main: a = %d, b = %d\n", a, b)
}

數組指針

//(*p)[0] = 666 數組指針賦值

package main //必須有個main包
import "fmt"
//p指向實現數組a，它是指向數組，它是數組指針
//*p代表指針所指向的內存，就是實參a
func modify(p *[5]int) {
	(*p)[0] = 666
	fmt.Println("modify *a = ", *p)  //modify *a =  [666 2 3 4 5]
}
func main() {
	a := [5]int{1, 2, 3, 4, 5} //初始化
	modify(&a) //地址傳遞
	fmt.Println("main: a = ", a)  // modify *a =  [666 2 3 4 5]
}

結構體指針變量

package main //必須有個main包
import "fmt"
//定義一個結構體類型
type Student struct {
	id   int
	name string
	sex  byte //字符類型
	age  int
	addr string
}
func main() {
	//順序初始化，每個成員必須初始化, 別忘了&
	var p1 *Student = &Student{1, "mike", 'm', 18, "bj"}
	fmt.Println("p1 = ", p1)  //p1 =  &{1 mike 109 18 bj}
	//指定成員初始化，沒有初始化的成員，自動賦值為0
	p2 := &Student{name: "mike", addr: "bj"}
	fmt.Printf("p2 type is %T\n", p2) //p2 type is *main.Student
	fmt.Println("p2 = ", p2)  //p2 =  &{0 mike 0 0 bj}
}

結構體成員普通變量

//定義一個結構體類型
type Student struct {
	id   int
	name string
	sex  byte //字符類型
	age  int
	addr string
}
func main() {
	//定義一個結構體普通變量
	var s Student
	//操作成員，需要使用點(.)運算符
	s.id = 1
	s.name = "mike"
	s.sex = 'm' //字符
	s.age = 18
	s.addr = "bj"
	fmt.Println("s = ", s) //s =  {1 mike 109 18 bj}
}

結構體成員指針變量

func main() {
	//1、指針有合法指向后，才操作成員
	//先定義一個普通結構體變量
	var s Student
	//在定義一個指針變量，保存s的地址
	var p1 *Student
	p1 = &s
	//通過指針操作成員  p1.id 和(*p1).id完全等價，只能使用.運算符
	p1.id = 1
	(*p1).name = "mike"
	p1.sex = 'm'
	p1.age = 18
	p1.addr = "bj"
	fmt.Println("p1 = ", p1)
	//2、通過new申請一個結構體
	p2 := new(Student)
	p2.id = 1
	p2.name = "mike"
	p2.sex = 'm'
	p2.age = 18
	p2.addr = "bj"
	fmt.Println("p2 = ", p2)
}

結構體比較和賦值

func main() {
	s1 := Student{1, "mike", 'm', 18, "bj"}
	s2 := Student{1, "mike", 'm', 18, "bj"}
	s3 := Student{2, "mike", 'm', 18, "bj"}
	fmt.Println("s1 == s2 ", s1 == s2)
	fmt.Println("s1 == s3 ", s1 == s3)
	//同類型的2個結構體變量可以相互賦值
	var tmp Student
	tmp = s3
	fmt.Println("tmp = ", tmp)
}

結構體作為函數參數

func test02(p *Student) {
	p.id = 666
}
func main() {
	s := Student{1, "mike", 'm', 18, "bj"}
	test02(&s) //地址傳遞（引用傳遞），形參可以改實參
	fmt.Println("main: ", s)
}
func test01(s Student) {
	s.id = 666
	fmt.Println("test01: ", s)
}
func main01() {
	s := Student{1, "mike", 'm', 18, "bj"}
	test01(s) //值傳遞，形參無法改實參
	fmt.Println("main: ", s)
}

“go語言結構體指針操作的方法”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！