脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - Go语言指针使用分析与讲解

Go语言指针使用分析与讲解

2021-08-18 00:43极客江南 Golang

这篇文章主要介绍了Go语言指针使用分析与讲解,本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下

普通指针

  • 和C语言一样, 允许用一个变量来存放其它变量的地址, 这种专门用于存储其它变量地址的变量, 我们称之为指针变量
  • 和C语言一样, Go语言中的指针无论是什么类型占用内存都一样(32位4个字节, 64位8个字节)
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main
 
import (
    "fmt"
    "unsafe"
)
 
func main() {
 
    var p1 *int;
    var p2 *float64;
    var p3 *bool;
    fmt.Println(unsafe.Sizeof(p1)) // 8
    fmt.Println(unsafe.Sizeof(p2)) // 8
    fmt.Println(unsafe.Sizeof(p3)) // 8
}
  • 和C语言一样, 只要一个指针变量保存了另一个变量对应的内存地址, 那么就可以通过*来访问指针变量指向的存储空间
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main
 
import (
    "fmt"
)
 
func main() {
 
    // 1.定义一个普通变量
    var num int = 666
    // 2.定义一个指针变量
    var p *int = &num
    fmt.Printf("%p\n", &num) // 0xc042064080
    fmt.Printf("%p\n", p) // 0xc042064080
    fmt.Printf("%T\n", p) // *int
    // 3.通过指针变量操作指向的存储空间
    *p = 888
    // 4.指针变量操作的就是指向变量的存储空间
    fmt.Println(num) // 888
    fmt.Println(*p) // 888
}

指向数组指针

  • 在C语言中, 数组名,&数组名,&数组首元素保存的都是同一个地址
?
1
2
3
4
5
6
7
8
#include <stdio.h>
 
int main(){
     int arr[3] = {1, 3, 5};
     printf("%p\n", arr); // 0060FEA4
     printf("%p\n", &arr); // 0060FEA4
     printf("%p\n", &arr[0]); // 0060FEA4
}
  • 在Go语言中通过数组名无法直接获取数组的内存地址
?
1
2
3
4
5
6
7
8
9
package main
import "fmt"
 
func main() {
    var arr [3]int = [3]int{1, 3, 5}
    fmt.Printf("%p\n", arr) // 乱七八糟东西
    fmt.Printf("%p\n", &arr) // 0xc0420620a0
    fmt.Printf("%p\n", &arr[0]) // 0xc0420620a0
}
  • 在C语言中, 无论我们将数组名,&数组名,&数组首元素赋值给指针变量, 都代表指针变量指向了这个数组
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
 
int main(){
     int arr[3] = {1, 3, 5};
     int *p1 = arr;
     p1[1] = 6;
     printf("%d\n", arr[1]);
 
     int *p2 = &arr;
     p2[1] = 7;
     printf("%d\n", arr[1]);
 
     int *p3 = &arr[0];
     p3[1] = 8;
     printf("%d\n", arr[1]);
}
  • 在Go语言中, 因为只有数据类型一模一样才能赋值, 所以只能通过&数组名赋值给指针变量, 才代表指针变量指向了这个数组
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package main
 
import "fmt"
 
func main() {
    // 1.错误, 在Go语言中必须类型一模一样才能赋值
    // arr类型是[3]int, p1的类型是*[3]int
    var p1 *[3]int
    fmt.Printf("%T\n", arr)
    fmt.Printf("%T\n", p1)
    p1 = arr // 报错
    p1[1] = 6
    fmt.Println(arr[1])
 
    // 2.正确, &arr的类型是*[3]int, p2的类型也是*[3]int
    var p2 *[3]int
    fmt.Printf("%T\n", &arr)
    fmt.Printf("%T\n", p2)
    p2 = &arr
    p2[1] = 6
    fmt.Println(arr[1])
 
    // 3.错误, &arr[0]的类型是*int, p3的类型也是*[3]int
    var p3 *[3]int
    fmt.Printf("%T\n", &arr[0])
    fmt.Printf("%T\n", p3)
    p3 = &arr[0] // 报错
    p3[1] = 6
    fmt.Println(arr[1])
}
  • 注意点:
    • Go语言中的指针, 不支持C语言中的+1 -1和++ – 操作
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package main
 
import "fmt"
 
func main() {
 
 
    var arr [3]int = [3]int{1, 3, 5}
    var p *[3]int
    p = &arr
    fmt.Printf("%p\n", &arr) // 0xc0420620a0
    fmt.Printf("%p\n", p) // 0xc0420620a0
    fmt.Println(&arr) // &[1 3 5]
    fmt.Println(p) // &[1 3 5]
    // 指针指向数组之后操作数组的几种方式
    // 1.直接通过数组名操作
    arr[1] = 6
    fmt.Println(arr[1])
    // 2.通过指针间接操作
    (*p)[1] = 7
    fmt.Println((*p)[1])
    fmt.Println(arr[1])
    // 3.通过指针间接操作
    p[1] = 8
    fmt.Println(p[1])
    fmt.Println(arr[1])
 
    // 注意点: Go语言中的指针, 不支持+1 -1和++ --操作
    *(p + 1) = 9 // 报错
    fmt.Println(*p++) // 报错
    fmt.Println(arr[1])
}

指向切片的指针

  • 值得注意点的是切片的本质就是一个指针指向数组, 所以指向切片的指针是一个二级指针

Go语言指针使用分析与讲解

Go语言指针使用分析与讲解

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package main
 
import "fmt"
 
func main() {
    // 1.定义一个切片
    var sce[]int = []int{1, 3, 5}
    // 2.打印切片的地址
    // 切片变量中保存的地址, 也就是指向的那个数组的地址 sce = 0xc0420620a0
    fmt.Printf("sce = %p\n",sce )
    fmt.Println(sce) // [1 3 5]
    // 切片变量自己的地址, &sce = 0xc04205e3e0
    fmt.Printf("&sce = %p\n",&sce )
    fmt.Println(&sce) // &[1 3 5]
    // 3.定义一个指向切片的指针
    var p *[]int
    // 因为必须类型一致才能赋值, 所以将切片变量自己的地址给了指针
    p = &sce
    // 4.打印指针保存的地址
    // 直接打印p打印出来的是保存的切片变量的地址 p = 0xc04205e3e0
    fmt.Printf("p = %p\n", p)
    fmt.Println(p) // &[1 3 5]
    // 打印*p打印出来的是切片变量保存的地址, 也就是数组的地址 *p = 0xc0420620a0
    fmt.Printf("*p = %p\n", *p)
    fmt.Println(*p) // [1 3 5]
    
    // 5.修改切片的值
    // 通过*p找到切片变量指向的存储空间(数组), 然后修改数组中保存的数据
    (*p)[1] = 666
    fmt.Println(sce[1])
}

指向字典指针

  • 与普通指针并无差异
?
1
2
3
4
5
6
7
8
9
package main
import "fmt"
func main() {
 
    var dict map[string]string = map[string]string{"name":"lnj", "age":"33"}
    var p *map[string]string = &dict
    (*p)["name"] = "zs"
    fmt.Println(dict)
}

指向结构体指针

  • Go语言中指向结构体的指针和C语言一样
  • 结构体和指针
    • 创建结构体指针变量有两种方式
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main
import "fmt"
type Student struct {
    name string
    age int
}
func main() {
  // 创建时利用取地址符号获取结构体变量地址
  var p1 = &Student{"lnj", 33}
  fmt.Println(p1) // &{lnj 33}
 
  // 通过new内置函数传入数据类型创建
  // 内部会创建一个空的结构体变量, 然后返回这个结构体变量的地址
  var p2 = new(Student)
  fmt.Println(p2) // &{ 0}
}
  • 利用结构体指针操作结构体属性
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main
import "fmt"
type Student struct {
    name string
    age int
}
func main() {
  var p = &Student{}
  // 方式一: 传统方式操作
  // 修改结构体中某个属性对应的值
  // 注意: 由于.运算符优先级比*高, 所以一定要加上()
  (*p).name = "lnj"
  // 获取结构体中某个属性对应的值
  fmt.Println((*p).name) // lnj
 
  // 方式二: 通过Go语法糖操作
  // Go语言作者为了程序员使用起来更加方便, 在操作指向结构体的指针时可以像操作接头体变量一样通过.来操作
  // 编译时底层会自动转发为(*p).age方式
  p.age = 33
  fmt.Println(p.age) // 33
}

指针作为函数参数和返回值

  • 如果指针类型作为函数参数, 修改形参会影响实参
  • 不能将函数内的指向局部变量的指针作为返回值, 函数结束指向空间会被释放
  • 可以将函数内的局部变量作为返回值, 本质是拷贝一份

到此这篇关于Go语言指针使用分析与讲解的文章就介绍到这了,更多相关Go语言指针内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/weixin_44617968/article/details/117697061

  • 指针
  • GO语言

    • 延伸 · 阅读

    精彩推荐
    • Golanggo日志系统logrus显示文件和行号的操作

      go日志系统logrus显示文件和行号的操作

      这篇文章主要介绍了go日志系统logrus显示文件和行号的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      SmallQinYan12302021-02-02
    • Golanggolang的httpserver优雅重启方法详解

      golang的httpserver优雅重启方法详解

      这篇文章主要给大家介绍了关于golang的httpserver优雅重启的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，...

      helight2992020-05-14
    • GolangGolang中Bit数组的实现方式

      Golang中Bit数组的实现方式

      这篇文章主要介绍了Golang中Bit数组的实现方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      天易独尊11682021-06-09
    • Golanggo语言制作端口扫描器

      go语言制作端口扫描器

      本文给大家分享的是使用go语言编写的TCP端口扫描器，可以选择IP范围，扫描的端口，以及多线程，有需要的小伙伴可以参考下。 ...

      脚本之家3642020-04-25
    • Golanggolang如何使用struct的tag属性的详细介绍

      golang如何使用struct的tag属性的详细介绍

      这篇文章主要介绍了golang如何使用struct的tag属性的详细介绍，从例子说起，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看...

      Go语言中文网11352020-05-21
    • GolangGolang通脉之数据类型详情

      Golang通脉之数据类型详情

      这篇文章主要介绍了Golang通脉之数据类型，在编程语言中标识符就是定义的具有某种意义的词，比如变量名、常量名、函数名等等，Go语言中标识符允许由...

      羌4272021-11-24
    • Golanggolang 通过ssh代理连接mysql的操作

      golang 通过ssh代理连接mysql的操作

      这篇文章主要介绍了golang 通过ssh代理连接mysql的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      a165861639710342021-03-08
    • Golanggolang json.Marshal 特殊html字符被转义的解决方法

      golang json.Marshal 特殊html字符被转义的解决方法

      今天小编就为大家分享一篇golang json.Marshal 特殊html字符被转义的解决方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧 ...

      李浩的life12792020-05-27
    最近更新
    编辑推荐
    阅读排行
    热门标签
    gosublime 　 指针类型 　 new() 　 make() 　 并发模型 　 切片 　 静态WEB服务器 　 端口扫描器 　 Go语言入门教程 　 基础语 　 Slices 　 Maps 　 Golang编程 　 panic 　 接受者类型 　 嵌入类型 　 Slice 　 Golang教程 　 Golang项目 　 内存模型 　 开发环境搭建 　 大小端判断 　 代码组织结构 　 复合类型 　 GOPATH 　 工作目录 　 实例 　 struct类型 　 并发技术 　 buffered 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图