go强制类型转换type(a)以及范围引起的数据差异
更新时间：2023年10月09日 14:14:26 作者：海生
这篇文章主要为大家介绍了go强制类型转换type(a)以及范围引起的数据差异,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
一、介绍
golang中的类型转换分强制类型转换和类型断言普通变量类型int,float,string 都可以使用type(a)这种形式来进行强制类型转换
二、数字的类型转换int和float
1、整数类型 int
func TestInt(t *testing.T) {
var i int = -1
var i8 int8 = int8(i)
var i16 int16 = int16(i)
var i32 int32 = int32(i)
var i64 int64 = int64(i)
t.Log(i, i8, i16, i32, i64) //-1 -1 -1 -1 -1
var n int = 1111111
var n8 int8 = int8(n)
var n16 int16 = int16(n)
var n32 int32 = int32(n)
var n64 int64 = int64(n)
t.Log(n, n8, n16, n32, n64) //1111111 71 -3001 1111111 1111111
}我们发现当 在转换n的过程中，转成int8和int16的时候，出现了错误，为什么会这样？
在于int类型在mac上是默认的64个bit，
int8 表示 -128 到 127 之间的整数值 （8个bit）
int16 表示 -32768 和 32767 之间的整数值 (16个bit)
他们之间能够存储的范围是不相同的，如果超过了某个类型的范围就会出错。
2、正整数类型 uint
func TestUint(t *testing.T) {
var i uint = 1
var i8 uint8 = uint8(i)
var i16 uint16 = uint16(i)
var i32 uint32 = uint32(i)
var i64 uint64 = uint64(i)
t.Log(i, i8, i16, i32, i64) //1 1 1 1 1
var u uint = 1111111
var u8 uint8 = uint8(u)
var u16 uint16 = uint16(u)
var u32 uint32 = uint32(u)
var u64 uint64 = uint64(u)
t.Log(u, u8, u16, u32, u64) //1111111 71 62535 1111111 1111111
}在类型范围内的数据转换正确，范围外的转换错误。
3、int和uint之间的强制转换
func TestInt2(t *testing.T) {
var i int = -1
var i8 uint8 = uint8(i)
var i16 uint16 = uint16(i)
var i32 uint32 = uint32(i)
var i64 uint64 = uint64(i)
t.Log(i, i8, i16, i32, i64) //-1 255 65535 4294967295 18446744073709551615
var n int = 1
var n8 uint8 = uint8(n)
var n16 uint16 = uint16(n)
var n32 uint32 = uint32(n)
var n64 uint64 = uint64(n)
t.Log(n, n8, n16, n32, n64) //1 1 1 1 1
var u int = 1111111
var u8 uint8 = uint8(u)
var u16 uint16 = uint16(u)
var u32 uint32 = uint32(u)
var u64 uint64 = uint64(u)
t.Log(u, u8, u16, u32, u64) //1111111 71 62535 1111111 1111111
}我们发现当每种类型范围不一样的话，转换不留神还是会有很大的错误。
4、float32和float64的强制转换
func TestFloat(t *testing.T) {
var f32 float32 = 333.333
var f64 float64 = float64(f32)
t.Log(f32, f64) //333.333 333.3330078125
//都在各自的范围内
var fl64 float64 = 333.333
var fl32 float32 = float32(fl64)
t.Log(fl64, fl32) //333.333 333.333
//大类型的范围 超过小的类型范围
var flo64 float64 = 33333333333333333.333
var flo32 float32 = float32(flo64)
t.Log(flo64, flo32) //333.333 333.333
}首先我们判断float32和float64有什么不同，因为使用内存大小不一样，导致精度以及范围的不同。
- float32和float64互相转化，因为精度不一样，导致数据差异
- float32和float64互相转化，因为范围不一样，导致数据差异
5、float和int互相转换
func TestFloatInt(t *testing.T) {
var i int = 333
var f32 float32 = float32(i)
var f64 float64 = float64(i)
t.Log(i, f32, f64) //333 333 333
var f float32 = 333.3
var n int = int(f)
var n8 int8 = int8(f)
var n16 int16 = int16(f)
var n32 int32 = int32(f)
var n64 int64 = int64(f)
t.Log(f, n, n8, n16, n32, n64) //333.3 333 77 333 333 333
}因为是mac系统，我这里int是有符号64位整数数据类型。
| 类型 | 比特数 | 有效数字 | 数值范围 |
|---|---|---|---|
| int64 | 64 | -2^63 ( -9,223,372,036,854,775,808) | 2^63-1(+9,223,372,036,854,775,807 ) |
| float32 | 32 | 6-7 | -3.410(-38)～3.410(38) |
| float64 | 64 | 15-16 | -1.710(-308)～1.710(308) |
基本上当int转成float类型只要在范围内的就没有啥问题
而float转成int的时候，需要考虑，小数点后面的会自动的舍去，以及范围问题。
三、指针unsafe.Pointer任意类型与具体指针类型的转换
注意，指针unsafe.Pointer任意类型，只能转成 具体类型的指针类型
如转成int类型的指针类型 *int
强制准换的语法为 type(a)，那么就是这里(*int)(a)，而不是int(a)！
1、指针unsafe.Pointer转成int指针类型
func TestIntPointer(t *testing.T) {
//范围内可以正确转化的情况
var i int = 100
pi := unsafe.Pointer(&i)
//转成int相关类型
var n *int = (*int)(pi)
var n8 *int8 = (*int8)(pi)
var n16 *int16 = (*int16)(pi)
var n32 *int32 = (*int32)(pi)
var n64 *int64 = (*int64)(pi)
t.Log(*n, *n8, *n16, *n32, *n64)//100 100 100 100 100
//--------------------------
//范围超出的情况
var i2 int = 10000
pi2 := unsafe.Pointer(&i2)
//转成int相关类型
var nn *int = (*int)(pi2)
var nn8 *int8 = (*int8)(pi2)
var nn16 *int16 = (*int16)(pi2)
var nn32 *int32 = (*int32)(pi2)
var nn64 *int64 = (*int64)(pi2)
t.Log(*nn, *nn8, *nn16, *nn32, *nn64)//10000 16 10000 10000 10000
}这里虽然是指针了，但还是需要注意具体类型的范围。
不然超出类型的最大或者最小值，仍然是错误的。
2、指针unsafe.Pointer转成struct指针类型
还是type(a)的方式，这里的a变量为 unsafe.Pointer(&a)
type为 (*Struct)
完整的表达式为 (*Struct)(unsafe.Pointer(&a))
func TestStruct(t *testing.T) {
//有一个struct结构体S，里面width和height两个int类型
type S struct {
wight int
height int
}
s := S{
wight: 5,
height: 6,
}
p := unsafe.Pointer(&s) //{5 6}
t.Log(s)
//测试转成为T，T里面有w和h两个int类型
type T struct {
w int
h int
}
st := (*T)(p)
t.Log(*st) //{5 6}
}发现虽然S和T两个结构体不一样，但却转成了正确的值，为什么？
因为指针关注的内存控股，不管是S里的wight或者T里面的w，其实都是int类型，占用了相同的内存
所以能够正确的解析出来
如果此时我们把 T的类型改一下成int8试试，就会发现错误
func TestStruct(t *testing.T) {
//有一个struct结构体S，里面width和height两个int类型
type S struct {
wight int
height int
}
s := S{
wight: 5,
height: 6,
}
p := unsafe.Pointer(&s) //{5 6}
t.Log(s)
//测试转成为T，T里面有w和h两个int8类型
type T struct {
w int8
h int8
}
st := (*T)(p)
t.Log(*st) //{5 0}
}第一个获取的5值，是因为在指针的0偏移量所以能够获取到，也正好在范围内，如果S.wight=10000
那么第一个也会错误，如下
func TestStruct(t *testing.T) {
//有一个struct结构体S，里面width和height两个int类型
type S struct {
wight int
height int
}
s := S{
wight: 10000,
height: 6,
}
p := unsafe.Pointer(&s) //{10000 6}
t.Log(s)
//测试转成为T，T里面有w和h两个int8类型
type T struct {
w int8
h int8
}
st := (*T)(p)
t.Log(*st) //{16 39}
}所以我们可以得出如果是指针类型的话，只要里面的指针是一样的，才能强制转换成正确的值。
以上就是go强制类型转换type(a)以及范围引起的数据差异的详细内容，更多关于go强制类型转换type数据差异的资料请关注脚本之家其它相关文章！
相关文章
这篇文章主要详细为大家介绍了Golang中的同步工具sync.WaitGroup，文中有详细的代码示例，具有很好的参考价值，希望对大家有所帮助，一起跟随小编过来看看吧2023-05-05
RSA 是最常用的非对称加密算法,本文主要介绍了Golang RSA生成密钥、加密、解密、签名与验签的实现,具有一定的参考价值,感兴趣的可以了解一下2023-11-11
本文深入分析了Go语言实现MySQL数据库事务的原理和实现方式，包括事务的ACID特性、事务的隔离级别、事务的实现方式等。同时，本文还介绍了Go语言中的事务处理机制和相关的API函数，以及如何使用Go语言实现MySQL数据库事务。2023-06-06
这篇文章主要介绍了golang接口的正确用法分享的相关资料,需要的朋友可以参考下2023-09-09
Go语言中有缓冲的通道是一种在被接收前能存储一个或者多个值的通道,本文就来介绍一下Go语言带缓冲的通道的使用,具有一定的参考价值,感兴趣的可以了解一下2024-01-01
这篇文章主要介绍了golang中的const常量和iota，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2022-12-12
在 Go 语言中，指针是一种重要的概念，了解和正确使用指非常关键，因此本文小编就来和大家讲讲Golang 中指针的概念与用法，希望对大家有所帮助2023-05-05
这篇文章主要为大家详细介绍了Go语言内存分配之结构体优化技巧的相关知识,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下2023-11-11
set集合是一种常见的数据结构,它代表了一个唯一元素的集合,本文主要介绍了set的基本特性,包括唯一性、无序性、可变性和集合运算,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧2024-10-10
这篇文章主要为大家介绍了Go语言io.LimitedReader类型示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2023-07-07
最新评论