成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

操作無符號整數的注意事項

作者：編程技術之道
開發 后端
在很多強類型編程語言中都會有一種特殊的類型——無符號整數類型，該數據類型在使用過程中往往稍不留意就會引發出乎意料的bug。

[[408212]]

在很多強類型編程語言中都會有一種特殊的類型——無符號整數類型，該數據類型在使用過程中往往稍不留意就會引發出乎意料的bug。

至于，有什么注意事項以及需要了解的知識點，一起來看看吧。

1. go源碼中的數據類型

  1. // go源碼位置: src/math/const.go 
  2. // 
  3. // Integer limit values. 
  4. const ( 
  5.     MaxInt8   = 1<<7 - 1 
  6.     MinInt8   = -1 << 7 
  7.    
  8.     MaxInt16  = 1<<15 - 1 
  9.     MinInt16  = -1 << 15 
  10.    
  11.     MaxInt32  = 1<<31 - 1 
  12.     MinInt32  = -1 << 31 
  13.    
  14.     MaxInt64  = 1<<63 - 1 
  15.     MinInt64  = -1 << 63 
  16.    
  17.     MaxUint8  = 1<<8 - 1 
  18.     MaxUint16 = 1<<16 - 1 
  19.     MaxUint32 = 1<<32 - 1 
  20.     MaxUint64 = 1<<64 - 1 
  21. ) 
  22.  
  23.  
  24. // go源碼位置: src/builtin/builtin.go 
  25. // 
  26. // uint8 is the set of all unsigned 8-bit integers. 
  27. // Range: 0 through 255. 
  28. type uint8 uint8 
  29.  
  30. // uint16 is the set of all unsigned 16-bit integers. 
  31. // Range: 0 through 65535. 
  32. type uint16 uint16 
  33.  
  34. // uint32 is the set of all unsigned 32-bit integers. 
  35. // Range: 0 through 4294967295. 
  36. type uint32 uint32 
  37.  
  38. // uint64 is the set of all unsigned 64-bit integers. 
  39. // Range: 0 through 18446744073709551615. 
  40. type uint64 uint64 
  41.  
  42. // int8 is the set of all signed 8-bit integers. 
  43. // Range: -128 through 127. 
  44. type int8 int8 
  45.  
  46. // int16 is the set of all signed 16-bit integers. 
  47. // Range: -32768 through 32767. 
  48. type int16 int16 
  49.  
  50. // int32 is the set of all signed 32-bit integers. 
  51. // Range: -2147483648 through 2147483647. 
  52. type int32 int32 
  53.  
  54. // int64 is the set of all signed 64-bit integers. 
  55. // Range: -9223372036854775808 through 9223372036854775807. 
  56. type int64 int64 
  57.  
  58. // float32 is the set of all IEEE-754 32-bit floating-point numbers. 
  59. type float32 float32 
  60.  
  61. // float64 is the set of all IEEE-754 64-bit floating-point numbers. 
  62. type float64 float64 

 從源碼中可以看出：

  1. 無符號類型只有正數值域(最小值為0)，沒有負數值域
  2. 有符號類型有正、負數值域
  3. 無符號類型正數值域數值個數是有符號類型正數值域數值個數的2倍

以 uint8 與 int8 為例，無符號類型 uint8，正數值域 0 ~ 255 共 256個數值。有符號類型 int8，正數值域 0 ~ 127 共 128個數值。

2. 無符號類型與有符號類型的值域

可能你會問：相同長度的無符號、有符號類型，值域為什么是這樣的分布?

看過計算機微機原理的同學大概都會略知一二，明白其緣由：

  1. 計算機只認識0、1，每個0、1被稱為1個bit (bit是計算機中最小的單位)
  2. 計算機系統中所有的數值以及數據都使用0、1串組合存儲
  3. 不同的0、1組合，由于使用不同編碼、解碼方式才被賦予了不同的含義，進而擁有了各種不同數據類型

 

就拿長度都是8 bit的無符號類型uint8與有符號類型int8來說：

uint8無符號類型的8個bit位都用來表示數值

int8有符號類型的8個bit中，只有后7個bit位用來表示數值。剩余的一個bit用來表示符號位，為0表示正數值，為1表示負數值。

在二進制中，1個bit長度之差造成的表達值域就是2倍

3. 無符號類型與有符號類型的加減法

先看一段代碼：

  1. func demo() { 
  2.     var a uint8 = 1 
  3.     var b uint8 = 2 
  4.     v1 := a - b 
  5.     fmt.Println("uint8 1-2=", v1) 
  6.  
  7.     var c int8 = 1 
  8.     var d int8 = 2 
  9.     v2 := c - d 
  10.     fmt.Println("int8 1-2=", v2) 
  11.  
  12.     fmt.Println("---------------") 
  13.      
  14.     var e uint8 = math.MaxUint8 
  15.     var f uint8 = 1 
  16.     v3 := e + f 
  17.     fmt.Printf("uint8 255+1=%d  %T\n", v3, v3) 
  18.  
  19.     var g int8 = math.MaxInt8 
  20.     var h int8 = 1 
  21.     v4 := g + h 
  22.     fmt.Printf("int8 127+1=%d %T\n", v4, v4) 
  23. } 

聰明的你，猜下執行結果會是什么？

  1. uint8 - v1 1-2= 255 
  2. int8 - v2 1-2= -1 
  3. --------------- 
  4. uint8 - v3 255+1=0  uint8 
  5. int8 - v4 127+1=-128 int8 

結果分析：

  1. v3、v4在進行相加操作時，由于運算結果超出了對應的數值位長度而發生溢出，導致溢出的數據位無效
  2. v2結果正確
  3. v1不僅是本文重點之一，也會在很多場合中稍有不慎就導致嚴重bug

在網上看到的一個關于無符號整形減法產生的bug，如下圖所示：

4. 關于無符號整形加減法的一些結論

先說一些關于無符號整形加減法的結論：

1.無符號整形進行加法操作時會像其他類型一樣，在運算結果超出數值位時發生溢出

2.無符號整形進行減法操作時，運算結果有兩種情況

2.1 減數>=被減數，則最終結果大于等于0

2.2 減數<被減數，最終結果也大于等于0

關于無符號整形進行減法比較特殊，減數小于被減數時結果也大于等于0，是不是很意外。

總結一句話概括：無符號類型數值無論加減操作，其結果從不會小于0。

5. 無符號類型數值相減問題

  1. [root@localhost workspace]# cat -n t.go 
  2.      1 package main 
  3.      2 
  4.      3 import"fmt" 
  5.      4 
  6.      5 func main (){ 
  7.      6 var a uint8 = 1 
  8.      7 var b uint8 = 2 
  9.      8      v1 := a - b 
  10.      9 
  11.     10      fmt.Println("uint8 - v1 1-2=", v1) 
  12.     11  } 

 第8行代碼執行了兩個uint8無符號類型減法操作，得到結果v1。

  1. [root@localhost workspace]# go build -gcflags="-N -l -S" t.go 
  2. # command-line-arguments 
  3. "".main STEXT size=222 args=0x0 locals=0x80 funcid=0x0 
  4.     0x000000000 (/root/workspace/t.go:5)    TEXT    "".main(SB), ABIInternal, $128-0 
  5.     ...... 
  6.     0x002b00043 (/root/workspace/t.go:8)    MOVBLZX "".a+54(SP), AX 
  7.     0x003000048 (/root/workspace/t.go:8)    ADDL    $-2, AX // !!! 加 -2 
  8.     0x003300051 (/root/workspace/t.go:8)    MOVB    AL, "".v1+52(SP) 
  9.     0x003700055 (/root/workspace/t.go:10)   MOVB    AL, ""..autotmp_3+55(SP) 

首先，要說明一點：在計算機中沒有減法，只有加法操作(出乎你的意料)。

通過匯編代碼可以看出 a-b 被轉換成了a + (-b)，即 1-2 = 1+(-2)。

按理說1-2應該等于-1才對，這其中又發生了什么呢?

6. 負數的表達形式——補碼

前面說過，計算機只認識二進制的0、1，2屬于10進制的數值，10進制則可以看做是一種計算機上的編解碼規則。那么，其對應的二進制又是什么呢?

  1. func demo2() { 
  2.     var a, b, c uint8 
  3.     a = 1 
  4.     b = 2 
  5.     c = a + (-b) 
  6.  
  7.     fmt.Printf( 
  8.         "a的二進制為：%08b \n"+ 
  9.         "b的二進制為：%08b \n"+ 
  10.         "-b的二進制為：%08b \n"+ 
  11.         "c的二進制為：%08b \n"+ 
  12.         "c的十進制為：%d", a, b, -b, c, c, 
  13.     ) 
  14. } 

 執行結果為：

  1. a的二進制為：00000001 
  2. b的二進制為：00000010 
  3. -b的二進制為：11111110 
  4. c的二進制為：11111111 
  5. c的十進制為：255 

在計算機系統里面，數值有三種編碼：原碼、反碼、補碼。

  1. 反碼、補碼一般用于負數，反碼=負數對應正數的原碼取反，補碼=反碼+1
  2. 正數的原碼、反碼、補碼一樣
  3. 負數分兩種情況：3.1 對于有符號類型：負數的數值位使用補碼表示，同時設置符號位為13.2 對于無符號類型：負數的數值位使用補碼表示，由于無符號位，故無需設置符號位

由上文若干規則可知：

  1. uint8 類型的 -b 對應的二進制為 11111110，uint8 類型 a 對應二進制為00000001
  2. c=a+(-b)，則對應bit位相加為11111111
  3. 同類型相加結果還為同一類型，所以c仍然為uint8
  4. 由于無符號類型的值域不存在負數域，所以11111111轉換為十進制為255

7. 一些疑惑

你是否跟我一樣，存在一些疑惑?

無符號類型可以賦值為負數嗎?

你可能會問：無符號類型既然永遠不為負數，那么可以賦值為負數嗎?

  1. func demo3() { 
  2.     var a uint8 
  3.     a = -2 
  4.  
  5.     fmt.Println(a) 
  6. } 

執行結果：

  1. # command-line-arguments 
  2. ./main.go:59:4: constant -2 overflows uint8 

通過報錯信息可知，是無法給無符號類型賦值負數的。

無符號類型不可以賦值負數，為什么可以進行取負操作?

既然無符號類型不可以賦值為負數，為什么無符號類型可以取負操作?

  1. func demo3() { 
  2.     var a uint8 
  3.     a = 2 
  4.  
  5.     fmt.Println(-a) 
  6. } 

可能你又會問：-a需要跟a類型一致才對，-a不能表示為無符號類型，為什么沒報錯呢?

  1. [root@localhost workspace]# cat -n t.go 
  2.      1 package main 
  3.      2 
  4.      3 import"fmt" 
  5.      4 
  6.      5 func main (){ 
  7.      6 var a1 uint8 
  8.      7      a1 = 2 
  9.      8 
  10.      9      fmt.Printf("%b\n", -a1) 
  11.     10  } 
  12.  
  13.  
  14. [root@localhost workspace]# go build -gcflags="-N -l -S" t.go 
  15. # command-line-arguments 
  16. "".main STEXT size=197 args=0x0 locals=0x80 funcid=0x0 
  17.     0x000000000 (/root/workspace/t.go:5)    TEXT    "".main(SB), ABIInternal, $128-0 
  18.     ...... 
  19.     0x002b00043 (/root/workspace/t.go:9)    MOVB    $-2, ""..autotmp_1+71(SP) 
  20.     0x003000048 (/root/workspace/t.go:9)    XORPS   X0, X0 
  21.     0x003300051 (/root/workspace/t.go:9)    MOVUPS  X0, ""..autotmp_2+80(SP) 
  22.     0x003800056 (/root/workspace/t.go:9)    LEAQ    ""..autotmp_2+80(SP), AX 
  23.     0x003d00061 (/root/workspace/t.go:9)    MOVQ    AX, ""..autotmp_4+72(SP) 
  24.     0x004200066 (/root/workspace/t.go:9)    TESTB   AL, (AX) 
  25.     0x004400068 (/root/workspace/t.go:9)    MOVBLZX ""..autotmp_1+71(SP), CX 
  26.     0x004900073 (/root/workspace/t.go:9)    LEAQ    type.uint8(SB), DX //!!! type.uint8對-2進行類型轉換 
  27.     0x005000080 (/root/workspace/t.go:9)    MOVQ    DX, ""..autotmp_2+80(SP) 
  28.     0x005500085 (/root/workspace/t.go:9)    LEAQ    runtime.staticuint64s(SB), DX 
  29.     0x005c00092 (/root/workspace/t.go:9)    LEAQ    (DX)(CX*8), CX 
  30.     0x006000096 (/root/workspace/t.go:9)    MOVQ    CX, ""..autotmp_2+88(SP) 
  31.     0x006500101 (/root/workspace/t.go:9)    TESTB   AL, (AX) 
  32.     0x006700103 (/root/workspace/t.go:9)    JMP 105 
  33.     0x006900105 (/root/workspace/t.go:9)    MOVQ    AX, ""..autotmp_3+96(SP) 
  34.     0x006e00110 (/root/workspace/t.go:9)    MOVQ    $1, ""..autotmp_3+104(SP) 
  35.     0x007700119 (/root/workspace/t.go:9)    MOVQ    $1, ""..autotmp_3+112(SP) 
  36.     0x008000128 (/root/workspace/t.go:9)    LEAQ    go.string."%b\n"(SB), CX 
  37.     0x008700135 (/root/workspace/t.go:9)    MOVQ    CX, (SP) 
  38.     0x008b00139 (/root/workspace/t.go:9)    MOVQ    $3, 8(SP) 
  39.     0x009400148 (/root/workspace/t.go:9)    MOVQ    AX, 16(SP) 
  40.     0x009900153 (/root/workspace/t.go:9)    MOVQ    $1, 24(SP) 
  41.     0x00a200162 (/root/workspace/t.go:9)    MOVQ    $1, 32(SP) 
  42.     0x00ab00171 (/root/workspace/t.go:9)    PCDATA  $1, $0 
  43.     0x00ab00171 (/root/workspace/t.go:9)    CALL    fmt.Printf(SB) 
  44.     ...... 

通過匯編可以看到，通過type.uint8(SB), DX對運算結果進行了類型轉換。

因此，我們可以得出結論：-a是a與負號(-)的一種運算，運算結果的最終類型會被轉換為與a一致。

總結

本文通過若干示例，展示了無符號類型與有符號類型的差別和注意事項。

那么，什么時候用無符號類型，什么時候用有符號類型呢?

  1. 運算結果期待包含負數，則不能用無符號類型，此時最好使用有符號類型
  2. 運算結果不需要包含負數，并且希望類型的正數值域足夠大，此時最好使用無符號類型
  3. 能不用無符號類型就少用無符號類型，減少bug產生!!!

其他特殊場景，如：在go語言runtime中GPM的邏輯處理器P結構上，P存儲goroutine的本地隊列頭尾位置使用了無符號類型。

  1. type p struct { 
  2.     ...... 
  3.     // Queue of runnable goroutines. Accessed without lock. 
  4.     runqhead uint32// 本地運行隊列 頭位置 
  5.     runqtail uint32// 本地運行隊列 尾位置 
  6.     runq     [256]guintptr // 每個P可以有256個G 
  7.   ...... 
  8. } 
  9.  
  10. // runqput tries to put g on the local runnable queue. 
  11. // If next if false, runqput adds g to the tail of the runnable queue. 
  12. // If next is true, runqput puts g in the _p_.runnext slot. 
  13. // If the run queue is full, runnext puts g on the global queue. 
  14. // Executed only by the owner P. 
  15. // runqput把G放到p里。如果next為true，就放到下一個。否則就追加到隊尾。如果隊列滿了，就放到全局隊列。 
  16. func runqput(_p_ *p, gp *g, next bool) { 
  17.     ...... 
  18.     h := atomic.Load(&_p_.runqhead) // load-acquire, synchronize with consumers 
  19.     t := _p_.runqtail 
  20.    
  21.     // 放本地隊列 
  22.     ift-h < uint32(len(_p_.runq)) { 
  23.         _p_.runq[t%uint32(len(_p_.runq))].set(gp) 
  24.         atomic.Store(&_p_.runqtail, t+1) // store-release, makes the item available for consumption 
  25.         return 
  26.     } 
  27.     ...... 
  28. } 

由于t、h的數值是一直在進行+1操作，會超過uint32的最大表示范圍。

思考當 t、h溢出之后會怎么樣?會有問題嗎?

 

責任編輯：姜華 來源： 今日頭條
編程語言無符號整數數據類型
相關推薦

2011-05-03 16:58:55

噴墨打印機墨水

2009-10-30 10:05:48

雙線接入

2011-05-26 11:22:04

SEO

2010-08-17 16:29:03

UPS旁路

2011-07-21 14:28:17

MySQL事務事務保存點

2009-07-28 10:26:30

ASP.NET操作Ex

2009-12-15 17:47:17

VSIP

2021-11-16 10:35:59

云計算云計算環境云應用

2023-01-14 09:49:11

2010-11-26 16:27:01

MySQL使用變量

2011-09-26 11:02:10

2020-10-20 14:05:48

用戶需求分析IT

2010-04-15 11:32:54

Unix操作系統

2010-02-05 14:13:17

Android平臺

2010-06-13 15:52:36

MySQL 復制設置

2009-12-16 15:41:10

Ruby on Rai

2009-12-21 09:53:45

連接Oracle

2011-04-11 16:23:57

2010-05-07 10:19:48

Oracle 注意事項

2010-07-29 10:27:30

Flex鍵盤事件
點贊
收藏

51CTO技術棧公眾號

主站蜘蛛池模板： 午夜看片 | 亚洲a视频| 亚洲午夜精品 | 91视频麻豆| 伊人网综合 | 欧美一区2区三区4区公司 | 欧美日韩在线一区 | 亚洲一区二区三区高清 | 91精产国品一二三区 | 黄色a级一级片 | 久久成人精品 | 亚洲精品一二区 | 欧美精品一二三 | 亚洲欧美日韩在线不卡 | 久久久久九九九九 | 一级毛片免费看 | 91视频日本| 久久草视频 | 日韩毛片 | 蜜臀网| 久久精品综合网 | 一区二区三区在线观看免费视频 | 日韩视频在线免费观看 | 亚洲成人av | 国产一区二区在线播放 | 国产精品成人一区二区三区吃奶 | 欧美日韩亚洲视频 | 91精品久久久久久久久中文字幕 | 免费久久99精品国产婷婷六月 | 久久另类 | 51ⅴ精品国产91久久久久久 | 成人小视频在线 | 色毛片| 精品久久久久久久久久 | 亚洲狠狠丁香婷婷综合久久久 | 成人a在线 | 人人干在线视频 | 婷婷狠狠 | 日韩欧美国产一区二区三区 | 欧美成人在线免费 | 国产不卡在线 |