跟我一起来学golang之《指针》｜ 8月更文挑战

这是我参与8月更文挑战的第10天，活动详情查看：8月更文挑战

指针的概念

指针是存储另一个变量的内存地址的变量。我们都知道，变量是一种使用方便的占位符，用于引用计算机内存地址。

获取变量的地址

Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。

package main

import "fmt"

func main() {
   var a int = 90   

   fmt.Printf("变量的地址: %x\n", &a  )
}
复制代码

运行结果：

变量的地址: 41568a310
复制代码

声明指针

声明指针，*T是指针变量的类型，它指向T类型的值。

var var_name *var-type
复制代码

var-type 为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针。

var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */
复制代码

示例代码：

package main

import "fmt"

func main() {
   var a int= 90   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &a  /* 指针变量的存储地址 */

   fmt.Printf("a 变量的地址是: %x\n", &a  )

   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量的存储地址: %x\n", ip )

   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )
}
复制代码

运行结果：

a 变量的地址是: 41568a310
ip 变量的存储地址: 41568a310
*ip 变量的值: 90
复制代码

示例代码：

package main

import "fmt"

type name int8
type first struct {
    a int
    b bool
    name
}

func main() {
    a := new(first)
    a.a = 1
    a.name = 11
    fmt.Println(a.b, a.a, a.name)
}
复制代码

运行结果：

false 1 11
复制代码

未初始化的变量自动赋上初始值

package main

import "fmt"

type name int8
type first struct {
    a int
    b bool
    name
}

func main() {
    var a = first{1, false, 2}
    var b *first = &a
    fmt.Println(a.b, a.a, a.name, &a, b.a, &b, (*b).a)
}
复制代码

运行结果：

false 1 2 &{1 false 2} 1 0xc042068018 1
复制代码

获取指针地址在指针变量前加&的方式

空指针

Go 空指针
当一个指针被定义后没有分配到任何变量时，它的值为 nil。
nil 指针也称为空指针。
nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。
一个指针变量通常缩写为 ptr。

空指针判断：

if(ptr != nil)     /* ptr 不是空指针 */
if(ptr == nil)    /* ptr 是空指针 */
复制代码

获取指针的值

获取一个指针意味着访问指针指向的变量的值。语法是：*a

示例代码：

package main  
import (  
    "fmt"
)

func main() {  
    b := 255
    a := &b
    fmt.Println("address of b is", a)
    fmt.Println("value of b is", *a)
}
复制代码

操作指针改变变量的数值

示例代码：

package main

import (  
    "fmt"
)

func main() {  
    b := 255
    a := &b
    fmt.Println("address of b is", a)
    fmt.Println("value of b is", *a)
    *a++
    fmt.Println("new value of b is", b)
}
复制代码

运行结果

address of b is 0x1040a124  
value of b is 255  
new value of b is 256
复制代码

指针的指针

如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。

var ptr **int;
package main

import "fmt"

func main() {

   var a int
   var ptr *int
   var pptr **int

   a = 3000

   /* 指针 ptr 地址 */
   ptr = &a

   /* 指向指针 ptr 地址 */
   pptr = &ptr

   /* 获取 pptr 的值 */
   fmt.Printf("变量 a = %d\n", a )
   fmt.Printf("指针变量 *ptr = %d\n", *ptr )
   fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
}
复制代码

运行结果：

变量 a = 3000
指针变量 *ptr = 3000
指向指针的指针变量 **pptr = 3000
复制代码

函数指针和指针函数

函数指针:是指向函数的指针变量，即本质是一个指针变量。
指针函数:本质是一个函数。函数返回类型是某一类型的指针。

import "fmt"
/*
  函数指针:是指向函数的指针变量，即本质是一个指针变量。
  指针函数:本质是一个函数。函数返回类型是某一类型的指针.
*/
func main()  {

  //2.函数指针
  a := 100
  fmt.Println("a,",a)
  b := a
  fmt.Println("b,",b)
  b = 200
  fmt.Println(a, b)
  fmt.Println("------------------")
  fmt.Printf("函数add的类型：%T\n", add) // 函数add的类型：func(int, int) int
  fmt.Println("打印add函数：", add) //  0x1095bc0,函数的地址，可以理解为一个特殊的变量。
  fmt.Println("函数的执行结果：", add(a, b))
  var f1 func(int, int) int = add
  fmt.Println("f1的执行结果：", f1(a, b))

  fmt.Println("f1,",f1, ",add,",add) // f1, 0x1093bb0 ,add, 0x1093bb0

  /*
  结论：函数声明时，函数名本身就是一个指针。不需要加*。
  函数与函数赋值时，属于浅拷贝，拷贝指针，两个指针同时指向同一块内存空间。
  */
  /*
  1.指针函数：
   */
   res1:= fun1()
   fmt.Printf("res1:%p,%v\n",res1,*res1) //[1 3 5 7]
   res2 := fun1()
   fmt.Printf("res2:%p,%v\n",res2,*res2) //[1 3 5 7]
   res1[0] = 100
   fmt.Println(*res1) //[100 3 5 7]
   fmt.Println(*res2) //[1 3 5 7]
   fmt.Println("------------")

}

// 1.定义一个函数，求两个数的和
// 该函数的类型：func (int,int) int
func add(a, b int) int  {
  return a + b
}

//2.定义一个指针函数
func fun1() *[4]int{
  var arr [4] int
  for i:=0;i<len(arr);i++{
    arr[i] = i*2+1
  }
  fmt.Printf("数组地址：%p，数组内容：%v\n",&arr,arr) //[1 3 5 7]
  return &arr
}
复制代码

运行结果：

a, 100
b, 100
100 200
------------------
函数add的类型：func(int, int) int
打印add函数： 0x1095f20
函数的执行结果： 300
f1的执行结果： 300
f1, 0x1095f20 ,add, 0x1095f20
数组地址：0xc4200180e0，数组内容：[1 3 5 7]
res1:0xc4200180e0,[1 3 5 7]
数组地址：0xc420018140，数组内容：[1 3 5 7]
res2:0xc420018140,[1 3 5 7]
[100 3 5 7]
[1 3 5 7]
------------
复制代码

指针数组和数组指针

package main

import "fmt"

func main()  {
    /*
    数组指针和指针数组：
        指针数组：首先它是一个数组，数组的元素都是指针，数组占多少个字节由数组本身决定。
            它是“储存指针的数组”的简称。
        数组指针：首先它是一个指针，它指向一个数组。在32位系统下永远是占4 个字节。至于它指向的数组占多少字节，不知道。
            它是“指向数组的指针”的简称。
     */
     //1.普通数组
    num:=[4] int{1000,2000,3000,4000}
    fmt.Println(num) //[1 2 3 4]

    //2.指针数组：存储指针的数组
    var p [4]*int //定义指针型数组
    fmt.Printf("%T\n", p) //[4]*int
    for i:=0;i<len(num);i++{
        add := &num[i]
        fmt.Println(add)
        p[i] = add
    }

    fmt.Println(p) //[0xc4200160c0 0xc4200160c8 0xc4200160d0 0xc4200160d8]

    //3.数组指针：数组的指针
    var p2 *[4] int
    fmt.Printf("%T\n", p2) //*[4]int
    p2 = &num
    fmt.Println(p2) //&[1000 2000 3000 4000]
    for i:=0;i<len(num);i++{
        fmt.Println((*p2)[i])
    }

    //var p3 *[4]float64
    //var p4 [4]*float64
    //var p5 *[4]*float64
    //var p6 ** [4]*int

}
复制代码

运行结果：

[1000 2000 3000 4000]
[4]*int
0xc420084020
0xc420084028
0xc420084030
0xc420084038
[0xc420084020 0xc420084028 0xc420084030 0xc420084038]
*[4]int
&[1000 2000 3000 4000]
1000
2000
3000
4000
复制代码

使用指针传递函数的参数

示例代码

package main

import (  
    "fmt"
)

func change(val *int) {  
    *val = 55
}
func main() {  
    a := 58
    fmt.Println("value of a before function call is",a)
    b := &a
    change(b)
    fmt.Println("value of a after function call is", a)
}
复制代码

运行结果

value of a before function call is 58  
value of a after function call is 55
复制代码

不要将一个指向数组的指针传递给函数。请使用切片。

假设我们想对函数内的数组进行一些修改，并且对调用者可以看到函数内的数组所做的更改。一种方法是将一个指向数组的指针传递给函数。

package main

import (  
    "fmt"
)

func modify(arr *[3]int) {  
    (*arr)[0] = 90
}

func main() {  
    a := [3]int{89, 90, 91}
    modify(&a)
    fmt.Println(a)
}
复制代码

运行结果

[90 90 91]
复制代码

示例代码：

package main

import (  
    "fmt"
)

func modify(arr *[3]int) {  
    arr[0] = 90
}

func main() {  
    a := [3]int{89, 90, 91}
    modify(&a)
    fmt.Println(a)
}
复制代码

运行结果

[90 90 91]
复制代码

虽然将指针传递给一个数组作为函数的参数并对其进行修改，但这并不是实现这一目标的惯用方法。我们有切片。

示例代码：

package main

import (  
    "fmt"
)

func modify(sls []int) {  
    sls[0] = 90
}

func main() {  
    a := [3]int{89, 90, 91}
    modify(a[:])
    fmt.Println(a)
}
复制代码

运行结果：

[90 90 91]
复制代码

Go不支持指针算法。

package main

func main() {
​ b := […]int{109, 110, 111}
​ p := &b
​ p++
}

nvalid operation: p++ (non-numeric type *[3]int)

指针数组

package main

import "fmt"

const MAX int = 3

func main() {

   a := []int{10,100,200}
   var i int

   for i = 0; i < MAX; i++ {
      fmt.Printf("a[%d] = %d\n", i, a[i] )
   }
}
结果
a[0] = 10
a[1] = 100
a[2] = 200
复制代码

有一种情况，我们可能需要保存数组，这样我们就需要使用到指针。

package main

import "fmt"

const MAX int = 3

func main() {
   a := []int{10,100,200}
   var i int
   var ptr [MAX]*int;

   for  i = 0; i < MAX; i++ {
      ptr[i] = &a[i] /* 整数地址赋值给指针数组 */
   }

   for  i = 0; i < MAX; i++ {
      fmt.Printf("a[%d] = %d\n", i,*ptr[i] )
   }
}
结果
a[0] = 10
a[1] = 100
a[2] = 200
复制代码

指针作为函数参数

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 100
   var b int= 200

   fmt.Printf("交换前 a 的值 : %d\n", a )
   fmt.Printf("交换前 b 的值 : %d\n", b )

   /* 调用函数用于交换值
   * &a 指向 a 变量的地址
   * &b 指向 b 变量的地址
   */
   swap(&a, &b);

   fmt.Printf("交换后 a 的值 : %d\n", a )
   fmt.Printf("交换后 b 的值 : %d\n", b )
}

func swap(x *int, y *int) {
   var temp int
   temp = *x    /* 保存 x 地址的值 */
   *x = *y      /* 将 y 赋值给 x */
   *y = temp    /* 将 temp 赋值给 y */
}
复制代码

运行结果：

交换前 a 的值 : 100
交换前 b 的值 : 200
交换后 a 的值 : 200
交换后 b 的值 : 100
复制代码