Un article analysant la valeur maximale de Int in Go

Cet article est introduit par la colonne tutoriel go language pour présenter la valeur maximale de Int dans Go. J'espère qu'il sera utile aux amis dans le besoin !

                                                                                                           

Résumé :

import "math/bits"const (
    MaxUint uint = (1 << bits.UintSize) - 1
    MaxInt int = (1 << bits.UintSize) / 2 - 1
    MinInt int = (1 << bits.UintSize) / -2)

Contexte :

Je pense que vous savez que le type uint a la même taille que uint32 ou uint64 code> , selon votre plateforme. Généralement, la version sans taille n'est utilisée que s'il n'y a aucun risque de se rapprocher du maximum, car la version sans taille peut utiliser des types "natifs", qui dépendent de la plate-forme, et elle a tendance à être plus rapide. <code>uint类型的大小与uint32或uint64相同，具体取决于您所在的平台。通常，只有在没有接近最大值风险的情况下，才会使用无尺寸的版本，因为没有尺寸规格的版本可以使用“本机”类型，这取决于平台，并且它往往更快。

请注意，更 “快” 是因为使用非本机类型需要处理器执行额外的数学计算和边界检查，以便模拟更大或更小的整数。因此，处理器（或编译器的优化代码）性能会比添加边界检查的代码要好。

话虽如此，在某些情况下，了解您正在使用的内容仍然很有用。

“math/bits“ 包中含有以字节为单位的uint大小（译者注：UintSize ）。要确定最大值，将 1 左移许多位，再减去 1。即：(1 << bits.UintSize) - 1

请注意，在计算 uint 的最大值时，您通常需要将其显式放入一个 uint（或更大的类型）类型变量中，否则编译器可能会失败，因为它会默认尝试将该计算分配给一个有符号int（很明显，它不适合），所以：

const MaxUint uint = (1 << bits.UintSize) - 1

这是您问题的直接答案，但您可能对一些相关的计算感兴趣。

根据 spec，uint 和 int 的大小始终相同。

uint 32 位或 64 位

int 与 uint 大小相同

因此，我们也可以使用这个常量来确定 int 的最大值，方法是采用相同的答案并除以 2，然后减去 1。 即：(1 << bits.UintSize) / 2 - 1

以及 int 的最小值，通过将 1 移位那么多位并将结果除以 -2。 即：(1 << bits.UintSize) / -2

总之：

** MaxUint: ** (1 << bits.UintSize) - 1

** MaxInt: ** (1 << bits.UintSize) / 2 - 1

** MinInt: ** (1 << bits.UintSize) / -2

Notez que "plus rapide" est dû au fait que l'utilisation de types non natifs nécessite que le processeur effectue des vérifications mathématiques et des limites supplémentaires afin de simuler des entiers plus grands ou plus petits. Par conséquent, le processeur (ou le code optimisé du compilateur) fonctionnera mieux que le code qui ajoute des vérifications de limites.

Cela dit, il existe encore des situations où il est utile de savoir avec quoi on travaille.

Le package "math/bits" contient la taille du uint en octets (Note du traducteur : UintSize). Pour déterminer la valeur maximale, décalez 1 vers la gauche d'un certain nombre de positions et soustrayez 1. C'est-à-dire : (1 << bits.UintSize) - 1

---

Veuillez noter que lors du calcul de la valeur maximale d'un uint, vous devez généralement l'indiquer explicitement dans une variable de type uint (ou plus grand), sinon le compilateur risque d'échouer car il tentera par défaut d'attribuer le calcul à un int signé (très évidemment, ce n'est pas le cas ça ne rentre pas), donc :

package mainimport (
    "fmt"
    "math"
    "math/bits"
    "runtime"
    "strconv")func main() {
    var mi32 int64 = math.MinInt32    var mi64 int64 = math.MinInt64    var i32 uint64 = math.MaxInt32    var ui32 uint64 = math.MaxUint32    var i64 uint64 = math.MaxInt64    var ui64 uint64 = math.MaxUint64    var ui uint64 = (1 << bits.UintSize) - 1
    var i uint64 = (1<<bits.UintSize)/2 - 1
    var mi int64 = (1 << bits.UintSize) / -2

    fmt.Printf(" MinInt32: %d\n", mi32)
    fmt.Printf(" MaxInt32:  %d\n", i32)
    fmt.Printf("MaxUint32:  %d\n", ui32)
    fmt.Printf(" MinInt64: %d\n", mi64)
    fmt.Printf(" MaxInt64:  %d\n", i64)
    fmt.Printf("MaxUint64:  %d\n", ui64)
    fmt.Printf("  MaxUint:  %d\n", ui)
    fmt.Printf("   MinInt: %d\n", mi)
    fmt.Printf("   MaxInt:  %d\n", i)

    fmt.Println("MaxUint:", uint(math.MaxUint))
    fmt.Println("MinInt:", math.MinInt)
    fmt.Println("MaxInt:", math.MaxInt)

    fmt.Println("系统架构:", runtime.Compiler, runtime.GOARCH, runtime.GOOS)
    fmt.Println("Int 大小:", strconv.IntSize)}

Ceci est une réponse directe à votre question, mais vous pourriez être intéressé par certains calculs connexes.

Selon les spécifications, uint et int ont toujours la même taille.

🎜🎜uint🎜 32 bits ou 64 bits 🎜🎜🎜int🎜 Même taille que uint🎜🎜🎜Donc, nous pouvons également utiliser cette constante pour déterminer la valeur maximale d'un int en prenant la même réponse et en divisant par 2, puis en soustrayant 1. Soit : (1 << bits.UintSize) / 2 - 1🎜🎜 et la valeur minimale de int, en décalant 1 autant de chiffres et divisez le résultat par -2. Soit : (1 << bits.UintSize) / -2🎜🎜En bref : 🎜🎜** MaxUint : ** (1 << bits.UintSize) - 1🎜🎜** MaxInt : ** (1 << bits.UintSize) / 2 - 1🎜🎜** MinInt : ** (1 <&lt ; bits .UintSize) / -2🎜🎜Exemple complet (doit être le même que l'image ci-dessous) : 🎜

MinInt32: -2147483648
 MaxInt32:  2147483647MaxUint32:  4294967295
 MinInt64: -9223372036854775808
 MaxInt64:  9223372036854775807MaxUint64:  18446744073709551615
  MaxUint:  18446744073709551615
   MinInt: -9223372036854775808
   MaxInt:  9223372036854775807MaxUint: 18446744073709551615MinInt: -9223372036854775808MaxInt: 9223372036854775807系统架构: gc amd64 darwin
Int 大小: 64

🎜Sortie : 🎜rrreee🎜🎜🎜Adresse originale : https://stackoverflow.com/questions/ 6878...🎜 🎜Adresse de traduction : https://learnku.com/go/t/62359🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!