Go语言指针

什么是指针

指针是一个变量，其值是另一个变量的地址，即存储器位置的直接地址。类似变量或常量一样，必须要先声明一个指针，然后才能使用它来存储任何变量地址。

指针变量声明的一般形式是：

var var-name *var-type

这里，var-type是指针的基类型; 它必须是有效的Go数据类型，var-name是指针变量的名称。用于声明指针的星号(*)与用于乘法的星号相同。

但是，在此语句中，星号(*)用于将变量指定为指针。以下是有效的指针声明：

var ip *int //指向整型指针
var fp *float32 //指向浮点型指针

所有指针的值的实际数据类型(无论是整数，浮点数还是其他数据类型)都是相同的，它表示内存地址的长十六进制数。

不同数据类型的指针的唯一区别是指针所指向的是变量或常量的数据类型。

如何使用指针

每个变量都是一个内存位置，每个内存位置都有其定义的地址，可以使用”和”号(&)运算符来访问它，这个运算符表示内存中的地址。参考下面的例子，它将打印定义的变量的地址：

package main

import "fmt"

func main() {
   var a int = 10   

   fmt.Printf("Address of a variable: %x\n", &a  )
}

这是通过使用一元运算符*来返回位于操作数指定的地址的变量的值。下面的例子使用这些操作：

package main

import "fmt"

func main() {
   var a int= 20   
   var ip *int      

   ip = &a 

   fmt.Printf("a 内存地址: %x\n", &a  )
  
   fmt.Printf("ip 内存地址: %x\n", ip )

   fmt.Printf("*ip 值: %d\n", *ip )
}

当上面的代码编译和执行时，它产生结果如下：

a 内存地址: 10328000
ip 内存地址: 10328000
*ip 值: 20

Nil 指针

在Go语言中的nil指针Go编译器为指针变量分配一个Nil值，以防指针没有确切的地址分配。这是在变量声明的时候完成的。指定为nil值的指针称为nil指针。

nil指针是在几个标准库中定义的值为零的常量。参考下面的程序：

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("The value of ptr is : %x\n", ptr  )
}

当上面的代码编译和执行时，它产生结果如下：

The value of ptr is 0

在大多数操作系统上，程序不允许访问地址0处的内存，因为该内存是由操作系统保留的。

然而，存储器地址0具有特殊意义; 它表示指针不打算指向可访问的存储器位置。但是按照惯例，如果指针包含nil(零)值，则假设它不指向任何东西。

要检查是否为nil指针，可以使用if语句，如下所示：

if(ptr != nil)     
if(ptr == nil)    

指针数组

在理解指针数组的概念之前，看看下面的例子，它使用了一个3个整数的数组：

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("Value of a[%d] = %d\n", i, a[i] )
   }
}

当上述代码编译和执行时，它产生以下结果：

Value of a[0] = 10
Value of a[1] = 100
Value of a[2] = 200

可能有一种情况，当想要维护一个数组，它可以存储指向int或字符串或任何其他可用的数据类型的指针。下面是一个指向整数的指针数组的声明：

var ptr [MAX]*int;

这里将ptr声明为一个MAX整数的指针数组。

因此，ptr中的每个元素现在保存一个指向int值的指针。以下示例使用三个整数，它们将存储在指针数组中，如下所示：

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("Value of a[%d] = %d\n", i,*ptr[i] )
   }
}

当上述代码编译和执行时，它产生以下结果：

Value of a[0] = 10
Value of a[1] = 100
Value of a[2] = 200

指针传递到函数

Go编程语言允许传递一个指针到函数中。

为此，只需将函数的参数声明为指针类型。看看下面一个简单的例子，传递了两个指针给一个函数，并在函数里面改变它们的值，这个值反映在调用函数中：

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 )

	//将指针地址传入函数
	swappr(&a, &b);
	fmt.Printf("传指针地址改变后a : %d\n", a )
	fmt.Printf("传指针地址改变后b : %d\n", b )

	swapval(a, b);
	fmt.Printf("传值后a : %d\n", a )
	fmt.Printf("传值后b : %d\n", b )

}

func swappr(x *int, y *int) {
	var temp int
	temp = *x
	*x = *y
	*y = temp
}

func swapval(x int, y int) {
	var temp int
	temp = x
	x = y
	y = temp
}

当上述代码编译和执行时，它产生以下结果：

函数改变前a : 100
函数改变前b : 200
传指针地址改变后a : 200
传指针地址改变后b : 100
传值后a : 200
传值后b : 100

指针的指针

指向指针的指针是多重间接的形式或指针链。通常，指针包含变量的地址。当定义指向指针的指针时，第一个指针包含第二个指针的地址，它指向包含实际值的位置，如下所示。

作为指向指针的指针的变量必须如此声明。这是通过在其名称前面添加一个星号(*)来实现的。 例如，以下是一个指向int类型的指针的声明：

var ptr **int;

当目标值由指向指针的指针间接指向时，访问该值需要应用两个星号(**)运算符，如下面的示例所示：

package main

import "fmt"

func main() {

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

   a = 3000

   ptr = &a

   pptr = &ptr

   /* take the value using pptr */
   fmt.Printf("Value of a = %d\n", a )
   fmt.Printf("Value available at *ptr = %d\n", *ptr )
   fmt.Printf("Value available at **pptr = %d\n", **pptr)
}

当上述代码编译和执行时，它产生以下结果：

Value of var = 3000
Value available at *ptr = 3000
Value available at **pptr = 3000

小结

Go中的指针是很容易学习，也是比较有趣的。一些Go编程任务使用指针更容易执行，并且不使用指针不能执行其他任务，例如通过传入引用修改变量值等