- 微信
- 微博
  
  分享文章到微博
- 复制链接
  
  复制链接到剪贴板

突破语言golang中的类型限制

码乐发表于 2024/03/14 08:38:36 2024/03/14

【摘要】 1 简介在使用c语言编程时，常常因为类型的问题大伤脑筋，而其他语言比如java，python默认类型又是难以改变的，golang提供了一些方式用于喜欢hack的用户。 2 标准库unsafe的简单介绍在1.20中，标准库的unsafe包很小, 二个结构体类型，八个函数，在一个文件中。 package unsage type ArbitraryType int type IntegerTyp...

1 简介

在使用c语言编程时，常常因为类型的问题大伤脑筋，而其他语言比如java，python默认类型又是难以改变的，golang提供了一些方式用于喜欢hack的用户。

2 标准库unsafe的简单介绍

官方说明标准库 unsafe 包含绕过 Go 程序的类型安全的操作。

导入unsafe包可能是不可移植的，并且不受 Go 1 兼容性指南的保护。

在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.1 获取大小 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 但是类型明确的变量。

对齐系数 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，变量的地址必须可被该变量的对齐系数整除。

2.2 使用对齐的例子

我们使用相同字段，分别创建两个结构体属性分别为对齐或不对齐，帮助 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

小结

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

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

比如结构体的Cloud 字段。

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

本节源码地址：

https://github.com/hahamx/examples/tree/main/alg_practice/2_sys_io

点赞
收藏
关注作者

0/1000

抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认取消

加入云驻计划，成为创作者

华为云周边好礼
免费体验产品
特殊身份标识
线下官方门票
内部专家零距离
与10000+优质创作者共同成长

立即加入

突破语言golang中的类型限制

1 简介

2 标准库unsafe的简单介绍

2.1 获取大小 Sizeof

2.2 使用对齐的例子

小结

全部回复

设置昵称

关于作者

目录

加入云驻计划，成为创作者

突破语言golang中的类型限制

1 简介

2 标准库unsafe的简单介绍

2.1 获取大小 Sizeof

2.2 使用对齐的例子

小结

全部回复

设置昵称

关于作者

目录

加入云驻计划，成为创作者

推荐阅读

相关产品