Go(4[指針,Map])

Go指針

指針類型

1. 普通類型,變量存的就是值,也就是值類型.指針類型存的是地址

2. 獲取變量的地址,用&， 好比 a:=6 獲取a的地址:&a

3. 指針類型,變量存的是一個地址,這個地址存的纔是值！！

4. 獲取指針類型所指向的值,使用:* ，好比： var *p int ，使用*p獲取p所向的值

5. 指針初始化:默認值爲nil

1. 指針類型變量初始化:

1. 使用其餘變量地址給它賦值

2. 使用new分配:用來分配內存，主要⽤來分配值類型，⽐如int、 struct。返回的是指針

6. 語句塊內的變量,用完即銷燬
   

測試一:傳入一個int類型指針,並在函數中修改所指向的值

func test1(a *int)  {
   //* 是一個語法糖, *a 就是修改指針值
   *a = 100
}
func main()  {
    var a int =1
    //聲明b是一個指針類型
    var b *int
    //& 是一個語法糖, & 就是變量內存地址
    //賦值b指針指向a的地址
    b = &a
    
    test1(b)
    fmt.Printf("%p,%d\n",b,a)
}

測試二:使用new建立指針

func test2()  {
   //c 指針初始化:默認值爲nil
   // var c *int
   //直接賦值指針會出錯
   //*c = 200
   //出錯！！
   //fmt.Println(c)
   ///p 默認初始化nil
   var p *int
   var b int
   p = &b
   *p = 200 //b = 200

   if (p == &b) {
      fmt.Printf("equal\n")
   }

   fmt.Printf("%p %p %p\n", p, &b, &p)

   p = new(int)
   *p = 1000
   fmt.Printf("%d\n", *p)
   fmt.Printf("%p %p %p\n", p, &b, &p)

   if (p == &b) {
      fmt.Printf("equal")
   }

   //指針類型的變量初始化：1. 使用其餘變量地址給它賦值。 2. 使用new分配
}

測試三:使用指針修改字符串

func test3()  {
   //指針字符串修改
   var p *string
   //第一種方式
   p = new(string)
   *p="abc"
   fmt.Println("test3_1\n",*p)
   
   //第二種方式
   var str string = "hello word"
   p = &str
   fmt.Println("test3_2\n",p,*p)
}

測試四:使用指針修改切片

func test5()  {
   //指針切片修改
 
   fmt.Println("\n",a)
   //在make建立切片,建立後默認都是0
   a := make([]int,10)
   //給第0個元素賦值
   a[0] = 100
   fmt.Println("\n",a)


   //指針指向切片:默認是nil
   //p 是一個指針變量,有本身的內存地址,它的指針變量地址不會改變
   ////方法一:
   //聲明p爲一個指針
   var p *[]int
   fmt.Println("\n",p,&p)
   //而後使用new 建立指針
   p = new([]int)

   fmt.Println("\n",p,*p) //輸出一個 &[] 的值，就是指向切片
   //make建立一個切片,並指向p指針
   (*p) = make([]int,10)
   //修改第0個元素
   (*p)[0] = 100
   fmt.Println(p)


   //方法二
   //& 是一個語法糖, & 就是變量內存地址
   //直接指針賦值到&a的內存地址 a是切片
   p = &a
   (*p) [0] = 1000
   fmt.Println(a)

}

測試五:使用指針修改元組

//*[5]int 就是指針類型
//修改元組內數據
func test2(a *[5]int)  {
   a[0] = 1000
}

//函數的傳參就是。數據的copy！！！,由於內存地址都不同， 可是傳遞指針,或者切片內存地址就同樣
//內存地址都是不同！
func test1(a [5]int)  {
   a[0] = 1000
   fmt.Printf("test1:%p\n",&a)
}
func main()  {

   var a [5]int=[5]int{1,3,4,5}
   //&a 就是把a的內存地址傳遞過去
   test2(&a)
   test1(a)
   fmt.Printf("test1-2:%p\n",&a)
   fmt.Println(a)
}

總結:

1. 指針默認 var p *int 內容都是nil,須要new建立指針

1. 建立字符串的指針 寫法: p:=new(string)   注:省去var 定義了

2. 建立切片的指針 寫法 p:=new([]int)

2. var p *string  p是一個指針變量,有本身的內存地址,它的指針變量地址不會改變