1.指针

  1. - 一个指针变量指向了一个值的内存地址
  2. - 定义指针变量
  3. - 为指针变量赋值：&
  4. - 修改指针变量中多指向地址的值：*
  1. func main() {
  3.         var a int =10 //声明变量
  4.         fmt.Printf("a内存地址:%p\n",&a)
  6.         var p *int //声明指针
  7.         p=&a //p存储a的内存地址
  8.         fmt.Println("p存储的地址:",p)
  9.         fmt.Println("p自己的内存地址:",&p)
  11.         //修改a或者*p的值，所指向同一个地址的变量的值都会变化
  12.         a =20
  13.         fmt.Println("a的值",a)
  14.         fmt.Println("p的值",*p)
  15.         *p=30
  16.         fmt.Println("a的值",a)
  17.         fmt.Println("p的值",*p)
  18. }

2.指针指向指针

  1. - 格式：var p **int
  2. - 一个指针变量存放的是另一个指针变量的地址
  3. - 第一个指针变量存放第二个指针的地址，第二个指针存放变量的地址
  1. func main() {
  3.     var a int = 10 //声明普通变量
  4.     var ptr *int   //声明指针变量
  5.     var pptr **int //声明指向指针的指针变量
  6.     ptr = &a       //将a的地址赋值给ptr
  7.     pptr = &ptr    //将ptr的地址赋值给pptr
  8.     fmt.Printf("a的值是%d,a的地址是%p\n", a, &a)
  9.     fmt.Printf("*ptr的值是%d,*ptr存储的地址是%p,*ptr的地址是%p\n", *ptr, ptr, &ptr)
  10.     fmt.Printf("**pptr的值是%d,**ptr存储的地址是%p,**ptr的地址是%p\n", **pptr, pptr, &pptr)
  11.     **pptr = 20
  12.     fmt.Println(a, ",", *ptr) //20,20
  13. }

3.数组指针与指针数组

  1. - 数组指针：是一个指针，指向了数组
  1. func main() {
  2.     //创建数组
  3.     var a =[4]int{1,2,3,4}  
  4.     fmt.Printf("数组地址:%p\n",&a)
  5.     //创建一个指针，指向数组
  6.     var p *[4]int
  7.     p=&a
  8.     fmt.Printf("p指向的地址:%p\n",p)
  9.     fmt.Println("p自己的地址:",&p)
  10.     fmt.Println("p指向的值：",*p)
  12.     //用数组指针修改数组
  13.     //1.原生写法
  14.     (*p)[0]=100 
  15.     fmt.Println(a[0])
  16.     //2.简便写法
  17.     p[0]=200
  18.     fmt.Println(a[0])
  19. }
  1. - 指针数组：是一个数组，保存的指针
  1. func main() {
  2.     a:=1
  3.     b:=2
  4.     c:=3
  6.     //创建一个指针数组
  7.     var p=[3]*int{&a,&b,&c}
  8.     fmt.Println(p)
  10.     //通过指针修改a的值
  11.     *p[0]=100
  12.     fmt.Println(a)
  13.     a=200
  14.     fmt.Println(*p[0])
  15. }

4.指针函数

  1. - 函数的返回值是指针
  1. func main() {
  3.     //调用该函数返回的是一个指针
  4.     ptr := p1()
  5.     fmt.Println("ptr指向地址的值", *ptr)
  6.     fmt.Printf("ptr自己内存地址:%p\n", &ptr)
  7.     fmt.Printf("ptr指向的内存地址%p", ptr)
  8. }
  9. //类型为指针的函数
  10. func p1() *[4]int {
  11.     arr := [4]int{1, 2, 3, 4}
  12.     fmt.Printf("arr地址:%p\n", &arr)
  13.     return &arr //返回指针
  14. }

5.指针为函数的参数

  1. - 函数的参数为指针
  1. func main() {
  3.     a :=10
  4.     fmt.Println("a的地址是",&a)
  5.     p1(&a)
  7. }
  8. //参数为指针的函数
  9. func p1(ptr *int)  {
  10.     fmt.Println("ptr存放的地址是",ptr)    
  11.     fmt.Println("ptr的值是",*ptr)  
  12. }