人生苦短我使用GO——GO指针

目录

GO指针

空指针

指向指针的指针

                多重指针示例

指针作为函数参数

---

GO指针

        区别于C/C++中的指针，Go语言中的指针不能进行偏移和运算，是安全指针。

        Go中指针很容易，使用指针可以更简单的执行一些任务。

        变量是一种使用方便的占位符，用于引用计算机内存地址。

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

        指针概念 一个指针变量指向了一个值的内存地址。

        类似于变量和常量，在使用指针前需要声明指针。指针声明格式如下:

var var_name *var-type

var-type为指针类型,var_name为指针变量名，*号用于指定变量是作为一个指针。示例中这是一个指向int和float32的指针。 

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

使用指针流程 ·

①定义指针变量。

②为指针变量赋值。

③访问指针变量中指向地址的值。

在指针类型前面加上*号(前缀)来获取指针所指向的内容。

示例:

package main
​
import "fmt"
​
func main() {
    var (
        a  int = 10 //声明实际变量
        ip *int     //声明指针变量
    )
    ip = &a
    fmt.Println("a的值为:", a)
    fmt.Println("a的地址:", &a)
    fmt.Println("指针ip所指向位置:", ip)
    fmt.Println("指针ip所取得值:", *ip)
}
运行结果

a的值为: 10
a的地址: 0xc000014098
指针ip所指向位置: 0xc000014098
指针ip所取得值: 10

空指针

        当一个指针被定义后没有分配到任何变量时，它的值为nil。

        nil 指针也称为空指针。

nil在概念上和其它语言的null、None.nil、NULL一样,都指代零值或空值。

一个指针变量通常缩写为ptr。

示例:

package main
import "fmt"
​
func main(){
​
    var ptr *int
​
    fmt.Printf("ptr的值为:%x\n", ptr)
​
}
运行结果

ptr的值为:0
空指针判断

if(ptr l= nil)/* ptr不是空指针*/
if(ptr == nil)/*ptr是空指针*/
指针数组
示例：定义了长度为3的整形数组

package main
​
import "fmt"
​
func main() {
    var (
        a   = [3]int{10, 100, 200}
        prt [3]*int
    )
    for i := 0; i < len(a); i++ {
        prt[i] = &a[i]
​
        fmt.Printf("第%d个元素数组的指针地址%d\n", i+1, prt[i])
    }
​
    for j := 0; j < len(a); j++ {
        fmt.Printf("a的%d个元素的值=%d\n", j+1, *prt[j])
    }
}
​
运行结果

第1个元素数组的指针地址824633762152
第2个元素数组的指针地址824633762160
第3个元素数组的指针地址824633762168
a的1个元素的值=10
a的2个元素的值=100
a的3个元素的值=200

指向指针的指针

如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。当定义一个指向指针的指针变量时，第一个指针存放第二个指针的地址，第二个指针存放变量的地址:

 

指向指针的指针变量声明格式如下:

var ptr **int

示例方问指向指针的指针变量值需要使用两个*号。

package main
​
import "fmt"
​
func main() {
    var (
        a   int = 300
        ptr *int
        b   **int
    )
    ptr = &a
    b = &ptr
    fmt.Println("a的值：", a)
    fmt.Println("ptr=", ptr)         //a的存储地址
    fmt.Println("指针ptr=", *ptr)      //a的值
    fmt.Println("指向指针的指针pptr的值=", b) //存储ptr的地址
    fmt.Println(*b)                  //其实还是取了一个a的存储地址
    fmt.Println("指向指针的指针=", **b)     //pptr取值
    fmt.Println("b的地址",&b)
}
​
运行结果

a的值： 300
ptr= 0xc0000aa058
指针ptr= 300
指向指针的指针pptr的值= 0xc0000ce018
0xc0000aa058
指向指针的指针= 300
b的地址 0xc0000ce020

 

 

                多重指针示例

package main
​
​
​
import "fmt"
​
​
​
func main() {
​
  var a int = 5
​
  //把ptr指针 指向ss所在地址
​
  var ptr *int = &a
​
  //开辟一个新的指针，指向ptr指针指向的地方
​
  var pts *int = ptr
​
  //二级指针，指向一个地址，这个地址存储的是一级指针的地址
​
  var pto **int = &ptr
​
  //三级指针，指向一个地址，这个地址存储的是二级指针的地址，二级指针同上
​
  var pt3 ***int = &pto
​
  fmt.Println("a的地址:", &a,
​
    "\n 值", a, "\n\n",
    "ptr指针所在地址:", &ptr,
    "\n ptr指向的地址:", ptr,
    "\n ptr指针指向地址对应的值", *ptr, "\n\n",
​
     "pts指针所在地址:", &pts,
​
    "\n pts指向的地址:", pts,
​
    "\n pts指针指向地址对应的值:", *pts, "\n\n",
​
    "pto指针所在地址:", &pto,
​
    "\n pto指向的指针(ptr)的存储地址:", pto,
​
    "\n pto指向的指针(ptr)所指向的地址: ", *pto,
​
    "\n pto最终指向的地址对应的值(a)", **pto, "\n\n",
​
    "pt3指针所在的地址:", &pt3,
​
    "\n pt3指向的指针(pto)的地址:", pt3, //等于&*pt3,
​
    "\n pt3指向的指针(pto)所指向的指针的(ptr)地址", *pt3, //等于&**pt3,
​
    "\n pt3指向的指针(pto)所指向的指针(ptr)所指向的地址(a):", **pt3, //等于&***pt3,
​
    "\n pt3最终指向的地址对应的值(a)", ***pt3)
​
}
运行结果

a的地址: 0xc000014098 
 值 5 
​
 ptr指针所在地址: 0xc000006028 
 ptr指向的地址: 0xc000014098 
 ptr指针指向地址对应的值 5 
​
 pts指针所在地址: 0xc000006030 
 pts指向的地址: 0xc000014098 
 pts指针指向地址对应的值: 5 
​
 pto指针所在地址: 0xc000006038 
 pto指向的指针(ptr)的存储地址: 0xc000006028 
 pto指向的指针(ptr)所指向的地址:  0xc000014098 
 pto最终指向的地址对应的值(a) 5 
​
 pt3指针所在的地址: 0xc000006040 
 pt3指向的指针(pto)的地址: 0xc000006038 
 pt3指向的指针(pto)所指向的指针的(ptr)地址 0xc000006028 
 pt3指向的指针(pto)所指向的指针(ptr)所指向的地址(a): 0xc000014098 
 pt3最终指向的地址对应的值(a) 5

指针作为函数参数

Go 语言允许向函数传递指针，只需要在函数定义的参数上设置为指针类型即可。

以下实例演示了如何向函数传递指针，并在函数调用后修改函数内的值。

package main
​
import "fmt"
​
func main() {
    /* 定义局部变量 */
   var a int = 100
   var b int= 200
   swap(&a, &b);
​
   fmt.Printf("交换后 a 的值 : %d\n", a )
   fmt.Printf("交换后 b 的值 : %d\n", b )
}
​
/* 交换函数这样写更加简洁，也是 go 语言的特性，可以用下，c++ 和 c# 是不能这么干的 */
 
func swap(x *int, y *int){
    *x, *y = *y, *x
}
交换前 a 的值 : 100
交换前 b 的值 : 200
交换后 a 的值 : 200
交换后 b 的值 : 100

1:调用函数，主程序中的值需要函数变更后的结果，直接通过返回值的方式处理

2:调用函数，主程序中的值需要函数便后后的记过，直接传入指针变量来处理