AI 助理
备案控制台
开发者社区 弹性计算 正文

go语言中进行不安全的类型操作

2024-05-20 124
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
无影云电脑个人版，1个月黄金款+200核时
资源编排，不限时长
无影云电脑企业版，4核8GB 120小时 1个月
简介： 【5月更文挑战第10天】Go语言中的`unsafe`包提供了一种不安全但强大的方式来处理类型转换和底层内存操作。包含两个文档用途的类型和八个函数，本文也比较了不同变量和结构体的大小与对齐系数，强调了字段顺序对内存分配的影响。

1 简单介绍

都知道c语言的类型是不安全，在go中如何做类型的突破？标准答案就是unsafe标准包。

question_ans.png

在go的1.20中，标准库的unsafe包很小, 二个结构体类型，八个函数，在一个文件中。

    package unsage

    type ArbitraryType int
    type IntegerType int
    type Pointer *ArbitraryType

    func Sizeof(x ArbitraryType) uintptr
    func Offsetof(x ArbitraryType) uintptr
    func Alignof(x ArbitraryType) uintptr

    func Add(ptr Pointer, len IntegerType) Pointer
    func Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType
    func SliceData(slice []ArbitraryType) *ArbitraryType
    func String(ptr *byte, len IntegerType) string
    func StringData(str string) *byte

unsafe包定义了 二个类型和 八个函数，二个类型 ArbitraryType 和 IntegerType 不真正属于unsafe包，我们在Go代码中并不能使用它们定义变量。

它表示一个任意表达式的类型，仅用于文档目的，Go编译器会对其做特殊处理。

虽然位于 unsafe，但是 Alignof，Offsetof，Sizeof，这三个函数的使用是绝对安全的。 以至于Go设计者Rob pike提议移走它们。

这三个函数的共同点是 都返回 uintptr 类型。

之所以使用 uintptr 类型而不是 uint64 整型，因为这三个函数更多应用于 有 unsafe.Pointer和 uintptr类型参数的指针运算。

采用uintptr做为返回值类型可以减少指针运算表达式的显式类型转换。

2 获取大小 Sizeof

Sizeof 用于获取一个表达式的大小。 该函数获取一个任意类型的表达式 x，并返回 按bytes计算 的大小，假设变量v，并且v通过 v =x声明。

Sizeof 接收任何类型的表达式x，并返回以bytes字节为单位的大小， 并且假设变量v是通过var v = x声明的。该大小不包括任何可能被x引用的内存。

例如，如果x是一个切片，Sizeof返回切片描述符的大小，而不是该片所引用的内存的大小。
对于一个结构体，其大小包括由字段对齐引入的任何填充。

如果参数x的类型没有变化，不具有可变的大小，Sizeof的返回值是一个Go常数不可变值 。
（如果一个类型是一个类型参数，或者是一个数组，则该类型具有可变的大小或结构类型中的元素大小可变）。

示例：

    var (
        i  int = 5
        a      = [10]int{}
        ss     = a[:]
        f  FuncFoo

        preValue = map[string]uintptr{
            "i":       8,
            "a":       80,
            "ss":      24,
            "f":       48,
            "f.c":     10,
            "int_nil": 8,
        }
    )

    type FuncFoo struct {
        a int
        b string
        c [10]byte
        d float64
    }


    func TestFuncSizeof(t *testing.T) {
        defer setUp(t.Name())()
        fmt.Printf("\tExecute test:%v\n", t.Name())

        if unsafe.Sizeof(i) != preValue["i"] {
            ErrorHandler(fmt.Sprintf("size: %v not equal %v", unsafe.Sizeof(i), preValue["i"]), t)
        }

        if unsafe.Sizeof(a) != preValue["a"] {
            ErrorHandler(fmt.Sprintf("size: %v not equal %v", unsafe.Sizeof(i), preValue["a"]), t)

        }

        if unsafe.Sizeof(ss) != preValue["ss"] {
            ErrorHandler(fmt.Sprintf("size: %v not equal %v", unsafe.Sizeof(i), preValue["ss"]), t)

        }
        if unsafe.Sizeof(f) != preValue["f"] {
            ErrorHandler(fmt.Sprintf("size: %v not equal %v", unsafe.Sizeof(i), preValue["f"]), t)

        }
        if unsafe.Sizeof(f.c) != preValue["f.c"] {
            ErrorHandler(fmt.Sprintf("size: %v not equal %v", unsafe.Sizeof(i), preValue["f.c"]), t)

        }
        if unsafe.Sizeof(unsafe.Sizeof((*int)(nil))) != preValue["int_nil"] {
            ErrorHandler(fmt.Sprintf("size: %v not equal %v", unsafe.Sizeof(i), preValue["int_nil"]), t)

        }
    }

Sizeof 函数不支持直接传入无类型信息的nil值，如下错误

    unsafe.Sizeof(nil)

我们必须显式告知 Sizeof 传入的nil究竟是那个类型，

    unsafe.Sizeof(unsafe.Sizeof((*int)(nil)))

必须显式告知nil是哪个类型的nil，这就是传入一个值 nil 但是类型明确的变量。

3 对其系数 Alignof

对齐系数 Alignof 用于获取一个表达式的内地地址对齐系数，对齐系数 alignment factor 是一个计算机体系架构 computer architecture 层面的术语。

在不同计算机体系中，处理器对变量地址都有对齐要求，即变量的地址必须可被该变量的对齐系数整除。

它接收一个任何类型的表达式x，并返回所需的排列方式 假设变量v是通过var v = x声明的。
它是m一个最大的值。

例1，

        a      = [10]int{}

        reflect.TypeOf(x).Align()  //8
        unsafe.Alignof(a)   //8

它与reflect.TypeOf(x).Align()返回的值相同。

作为一个特例，如果一个变量s是结构类型，f是一个字段，那么Alignof(s.f)将返回所需的对齐方式。

该类型的字段在结构中的位置。这种情况与reeflect.TypeOf(s.f).FieldAlign()返回的值。

Alignof的返回值是一个Go常数，如果参数的类型不具有可变大小。
（关于可变大小类型的定义，请参见[Sizeof]的描述）。

继上 例2：

      var (
        i  int = 5
        a      = [10]int{}
        ss     = a[:]
        f  FuncFoo
        zhs = "文"

        preValue = map[string]uintptr{
            "i":       8,
            "a":       80,
            "ss":      24,
            "f":       48,
            "f.c":     10,
            "int_nil": 8,
        }
    )

    func TestAlignof(t *testing.T) {

        defer setUp(t.Name())()
        fmt.Printf("\tExecute test:%v\n", t.Name())

        var x int 

        b := uintptr(unsafe.Pointer(&x))%unsafe.Alignof(x) == 0
        t.Log("alignof:", b)

        if unsafe.Alignof(i) != preValue["i"] {
            ErrorHandler(fmt.Sprintf("Alignof: %v not equal %v", unsafe.Sizeof(i), preValue["int_nil"]), t)

        }

        if unsafe.Alignof(a) != preValue["i"] {
            ErrorHandler(fmt.Sprintf("Alignof: %v not equal %v", unsafe.Sizeof(i), preValue["int_nil"]), t)

        }

        if unsafe.Alignof(ss) != preValue["i"] {
            ErrorHandler(fmt.Sprintf("Alignof: %v not equal %v", unsafe.Sizeof(i), preValue["int_nil"]), t)

        }

        if unsafe.Alignof(f.a) != preValue["i"] {
            ErrorHandler(fmt.Sprintf("Alignof: %v not equal %v", unsafe.Sizeof(i), preValue["int_nil"]), t)

        }

        if unsafe.Alignof(f) != preValue["i"] {
            ErrorHandler(fmt.Sprintf("Alignof: %v not equal %v", unsafe.Sizeof(i), preValue["int_nil"]), t)

        }

中文对齐系数 为 8

        if unsafe.Alignof(zhs) != preValue["i"] {
            ErrorHandler(fmt.Sprintf("Alignof: %v not equal %v", unsafe.Sizeof(i), preValue["i"]), t)
        }

空结构体对齐系数 1

        if unsafe.Alignof(struct{}{}) != 1 {
            ErrorHandler(fmt.Sprintf("Alignof: %v not equal %v", unsafe.Sizeof(i), 1), t)
        }

byte 数组对齐系数为 1

        if unsafe.Alignof(sbyte) != 1 {
            ErrorHandler(fmt.Sprintf("Alignof: %v not equal %v", unsafe.Sizeof(i), 1), t)
        }

长度为0 的数组，与其元素的对齐系数相同

        if unsafe.Alignof([0]int{}) != 8 {
            ErrorHandler(fmt.Sprintf("Alignof: %v not equal %v", unsafe.Sizeof(i), 8), t)
        }

长度为0 的数组，与其元素的对齐系数相同

        if unsafe.Alignof([0]struct{}{}) != 1 {
            ErrorHandler(fmt.Sprintf("Alignof: %v not equal %v", unsafe.Sizeof(i), 1), t)
        }

    }

执行它：

    go test -timeout 30s -run ^TestAlignof$ ./unsafe_case.go

对齐系数 alignment factor，变量的地址必须可被该变量的对齐系数整除。

4 使用对齐的例子

我们使用相同字段，分别创建两个结构体属性分别为对齐或不对齐，帮助 go 更好地分配内存和 使用cpu读取，查看效果

    type RandomResource struct {
        Cloud               string // 16 bytes
        Name                string // 16 bytes
        HaveDSL             bool   //  1 byte
        PluginVersion       string // 16 bytes
        IsVersionControlled bool   //  1 byte
        TerraformVersion    string // 16 bytes
        ModuleVersionMajor  int32  //  4 bytes
    }

    type OrderResource struct {
        ModuleVersionMajor  int32  //  4 bytes
        HaveDSL             bool   //  1 byte
        IsVersionControlled bool   //  1 byte
        Cloud               string // 16 bytes
        Name                string // 16 bytes
        PluginVersion       string // 16 bytes
        TerraformVersion    string // 16 bytes

    }

字段 存储使用的空间与 字段值没有关系

         var d RandomResource
         d.Cloud = "aws-singapore"
         ...

         InfoHandler(fmt.Sprintf("随机顺序属性的结构体内存 总共占用 StructType: %T => [%d]\n", d, unsafe.Sizeof(d)), m)


         var te = OrderResource{}
         te.Cloud = "aws-singapore"  
         ...
         m.Logf("属性对齐的结构体内存 总共占用  StructType:d %T => [%d]\n", te, unsafe.Sizeof(te))

然后复制结构体，并改变其属性值，查看存储空间和值的长度变化

        te2 := te
        te2.Cloud = "ali2"
        m.Logf("结构体2 te2:%#v\n", &te2)
        m.Logf("结构体1 te:%#v\n", &te)

        m.Log("改变 te3 将同时改变 te,te3 指向了 te的地址")
        m.Log("复制了对齐结构体，并重新赋值，用于查看字段长度。")
        m.Log("(*te).Cloud:", (te).Cloud, "*te.Cloud", te.Cloud, "te size:", unsafe.Sizeof(te.Cloud), "te value len:", len(te.Cloud))

        te3 := &te
        te3.Cloud = "HWCloud2"

        m.Log("(*te3).Cloud:", (*te3).Cloud, "*te3.Cloud", te3.Cloud, "te3 size:", unsafe.Sizeof(te3.Cloud), "te3 value len:", len(te3.Cloud))
        m.Logf("字段 Cloud:%v te3:%p\n", (*te3).Cloud, te3)
        m.Logf("字段 Cloud:%v order:%v te:%v, addr:%p\n", te.Cloud, (te).Cloud, te, &te)

执行它，

    go test -v .\case_test.go

得到以下输出:

随机顺序属性的结构体内存 总共占用 StructType: main.Raesource => [88]

    ...

属性对齐的结构体内存 总共占用 StructType:d main.OrderResource => [72]

改变 te3 将同时改变 te,te3 指向了 te的地址

    case_test.go:186: 复制了对齐结构体，并重新赋值，用于查看字段长度。

    case_test.go:188: (*te).Cloud: aws-singapore *te.Cloud aws-singapore te size: 16 te Alignof: 8 te value len: 13 reflect Align len and field Align len: 8 8
    case_test.go:190: (*te2).Cloud: ali2 *te2.Cloud aws-singapore te2 size: 16 te2 Alignof: 8 te2 value len: 4 reflect Align len and field Align len: 8 8
    case_test.go:196: (*te3).Cloud: HWCloud2-asia-southeast-from-big-plant-place-air-local-video-service-picture-merge-from-other-all-company *te3.Cloud HWCloud2-asia-southeast-from-big-plant-place-air-local-video-service-picture-merge-from-other-all-company te3 
size: 16 te3 Alignof: 8 te3 value len: 105 reflect Align len and field Align len: 8 8

    case_test.go: 结构体1字段 Cloud:HWCloud2-asia-southeast-from-big-plant-place-air-local-video-service-picture-merge-from-other-all-company te2:0xc0000621e0
    case_test.go:198: 结构体2字段 Cloud:ali2 te2:0xc000062280
    case_test.go:199: 结构体3字段 Cloud:HWCloud2-asia-southeast-from-big-plant-place-air-local-video-service-picture-merge-from-other-all-company te3:0xc0000621e0

5 小结

我们介绍了unsafe包的检查功能，在初始化时，go结构体已经分配了对于的内存空间，

一个结构体而言，结构体属性为随机顺序的，go将分配更多内存空间。 即使是复制后。

比如 结构体的Cloud 字段。

Sizeof表达式大小总是16，
而对齐系数 Alignof 大小总是8，
而在不同的结构体实例中值长度可以为 4，13， 105.

本节源码地址：

https://github.com/hahamx/examples/tree/main/alg_practice/2_sys_io
文章标签：
Go
C语言
安全
存储
编译器
关键词：
Go语言
Go类型
Go语言安全
Go安全
Go操作
兀码
目录
相关文章
左诗右码
|
6天前
|
存储 JSON 监控
Viper，一个Go语言配置管理神器！
Viper 是一个功能强大的 Go 语言配置管理库，支持从多种来源读取配置，包括文件、环境变量、远程配置中心等。本文详细介绍了 Viper 的核心特性和使用方法，包括从本地 YAML 文件和 Consul 远程配置中心读取配置的示例。Viper 的多来源配置、动态配置和轻松集成特性使其成为管理复杂应用配置的理想选择。
左诗右码
23 2
听风de歌
|
4天前
|
Go 索引
go语言中的循环语句
【11月更文挑战第4天】
听风de歌
13 2
听风de歌
|
4天前
|
Go C++
go语言中的条件语句
【11月更文挑战第4天】
听风de歌
16 2
听风de歌
|
8天前
|
程序员 Go
go语言中的控制结构
【11月更文挑战第3天】
听风de歌
85 58
游客762btuqu5wybw666
|
7天前
|
监控 Go API
Go语言在微服务架构中的应用实践
在微服务架构的浪潮中，Go语言以其简洁、高效和并发处理能力脱颖而出，成为构建微服务的理想选择。本文将探讨Go语言在微服务架构中的应用实践，包括Go语言的特性如何适应微服务架构的需求，以及在实际开发中如何利用Go语言的特性来提高服务的性能和可维护性。我们将通过一个具体的案例分析，展示Go语言在微服务开发中的优势，并讨论在实际应用中可能遇到的挑战和解决方案。
游客762btuqu5wybw666
27 8
听风de歌
|
4天前
|
Go
go语言中的 跳转语句
【11月更文挑战第4天】
听风de歌
12 4
左诗右码
|
4天前
|
JSON 安全 Go
Go语言中使用JWT鉴权、Token刷新完整示例，拿去直接用！
本文介绍了如何在 Go 语言中使用 Gin 框架实现 JWT 用户认证和安全保护。JWT（JSON Web Token）是一种轻量、高效的认证与授权解决方案，特别适合微服务架构。文章详细讲解了 JWT 的基本概念、结构以及如何在 Gin 中生成、解析和刷新 JWT。通过示例代码，展示了如何在实际项目中应用 JWT，确保用户身份验证和数据安全。完整代码可在 GitHub 仓库中查看。
左诗右码
18 1
游客762btuqu5wybw666
|
8天前
|
Go 数据处理 API
Go语言在微服务架构中的应用与优势
本文摘要采用问答形式，以期提供更直接的信息获取方式。 Q1: 为什么选择Go语言进行微服务开发？ A1: Go语言的并发模型、简洁的语法和高效的编译速度使其成为微服务架构的理想选择。 Q2: Go语言在微服务架构中有哪些优势？ A2: 主要优势包括高性能、高并发处理能力、简洁的代码和强大的标准库。 Q3: 文章将如何展示Go语言在微服务中的应用？ A3: 通过对比其他语言和展示Go语言在实际项目中的应用案例，来说明其在微服务架构中的优势。
游客762btuqu5wybw666
29 6
游客762btuqu5wybw666
|
8天前
|
Go 数据处理 调度
探索Go语言的并发模型：Goroutines与Channels的协同工作
在现代编程语言中，Go语言以其独特的并发模型脱颖而出。本文将深入探讨Go语言中的Goroutines和Channels，这两种机制如何协同工作以实现高效的并发处理。我们将通过实际代码示例，展示如何在Go程序中创建和管理Goroutines，以及如何使用Channels进行Goroutines之间的通信。此外，本文还将讨论在使用这些并发工具时可能遇到的常见问题及其解决方案，旨在为Go语言开发者提供一个全面的并发编程指南。
游客762btuqu5wybw666
29 5
叫个什么名字
|
6天前
|
Go 调度 开发者
探索Go语言中的并发模式：goroutine与channel
在本文中，我们将深入探讨Go语言中的核心并发特性——goroutine和channel。不同于传统的并发模型，Go语言的并发机制以其简洁性和高效性著称。本文将通过实际代码示例，展示如何利用goroutine实现轻量级的并发执行，以及如何通过channel安全地在goroutine之间传递数据。摘要部分将概述这些概念，并提示读者本文将提供哪些具体的技术洞见。
叫个什么名字
8 2

弹性计算

热门文章

最新文章

  • 1
    惊呼！阿里云云服务器ECS最低3折售卖啦
  • 2
    ECS控制台使用小贴士
  • 3
    阿里云弹性计算_加速计算专场精华概览 | 2024云栖大会回顾
  • 4
    云服务器ECS安全组实践(三）Tips篇
  • 5
    ECS 系统盘支持一键扩容啦，无需更换系统盘
  • 6
    云服务器ECS安全组实践(一）
  • 7
    VPC实例公网IP转弹性公网IP功能
  • 8
    省钱小贴士（ECS）：教你如何每年省出8w+ 块
  • 9
    【F3使用场景】F3经典使用场景
  • 10
    阿里云基础产品技术月刊 2019年4月
  • 1
    阿里云通用算力型U1实例性能、适用场景、与经济型e区别、收费标准参考
    9
  • 2
    在硬件连接时，如何确定 GPIO 引脚的功能和编号
    9
  • 3
    阿里云GPU云服务器性能、应用场景及收费标准和活动价格参考
    15
  • 4
    阿里云服务器通用型g8i实例性能与使用场景介绍及最新收费标准参考
    17
  • 5
    Vue 双向数据绑定原理
    11
  • 6
    在 Service Worker 中配置缓存策略
    12
  • 7
    CacheStorage详解
    10
  • 8
    CAN 帧中 CRC 场的作用
    18
  • 9
    阿里云服务器经济型e和通用算力型u1实例区别及选择参考
    16
  • 10
    如何让 WordPress 快起来？Websoft9 教您实操
    27

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Go语言完全自学手册图文教程
  • Python语言基础 - 函数、面向对象、异常处理
  • Python语言基础 - 语法入门

    • 相关电子书

    更多
  • Go语言路上踩过的坑
  • gohbase ：HBase go客户端
  • Go构建日请求千亿级微服务实践

    • 相关实验场景

    更多
  • 函数类型-1：基本语法
  • 语言入门-2：基本类型
  • Python网络通信程序典型应用
    • 下一篇
    阿里云OSS设置跨域访问