Go(4[指针,Map])

Go指针

指针类型

普通类型,变量存的就是值,也就是值类型.指针类型存的是地址

获取变量的地址,用&， 比如 a:=6 获取a的地址:&a

指针类型,变量存的是一个地址,这个地址存的才是值！！

获取指针类型所指向的值,使用:* ，比如： var *p int ，使用*p获取p所向的值

指针初始化:默认值为nil

指针类型变量初始化:

使用其他变量地址给它赋值

使用new分配:用来分配内存，主要⽤来分配值类型，⽐如int、 struct。返回的是指针

语句块内的变量,用完即销毁

测试一:传入一个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)

}

总结:

指针默认 var p *int 内容都是nil,需要new创建指针

创建字符串的指针 写法: p:=new(string)   注:省去var 定义了

创建切片的指针 写法 p:=new([]int)

var p *string  p是一个指针变量,有自己的内存地址,它的指针变量地址不会改变

©著作权归作者所有：来自51CTO博客作者zhaichaoqun的原创作品，如需转载，请与作者联系，否则将追究法律责任