Ein Artikel, der den Maximalwert von Int in Go analysiert

Dieser Artikel wird von der Go-SpracheTutorial-Kolumne eingeführt, um den maximalen Wert von Int in Go vorzustellen. Ich hoffe, er wird Freunden in Not hilfreich sein!

                                                                                                               

Zusammenfassung:

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

Hintergrund:

Ich denke, Sie wissen, dass der Typ uint die gleiche Größe hat wie uint32 oder uint64 code> , abhängig von Ihrer Plattform. Typischerweise wird die größenlose Version nur verwendet, wenn kein Risiko besteht, sich dem Maximum zu nähern, da die größenlose Version „native“ Typen verwenden kann, was von der Plattform abhängt, und tendenziell schneller ist. <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

Beachten Sie, dass „schneller“ darauf zurückzuführen ist, dass die Verwendung nicht-nativer Typen vom Prozessor zusätzliche Mathematik- und Grenzprüfungen durchführen muss, um größere oder kleinere ganze Zahlen zu simulieren. Daher ist die Leistung des Prozessors (oder des vom Compiler optimierten Codes) besser als der Code, der Grenzüberprüfungen hinzufügt.

Dennoch gibt es immer noch Situationen, in denen es nützlich ist zu wissen, womit man arbeitet.

Das Paket „math/bits“ enthält die uint-Größe in Bytes (Anmerkung des Übersetzers: UintSize). Um den Maximalwert zu ermitteln, verschieben Sie 1 um mehrere Stellen nach links und subtrahieren 1. Das heißt: (1 << bits.UintSize) - 1

---

Bitte beachten Sie, dass Sie bei der Berechnung des Maximalwerts eines uint diesen normalerweise explizit eingeben müssen in einer Variablen vom Typ uint (oder größer), andernfalls schlägt der Compiler möglicherweise fehl, da er standardmäßig versucht, die Berechnung einem signierten int zuzuweisen (was ganz offensichtlich der Fall ist). passt nicht), also:

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)}

Dies ist eine direkte Antwort auf Ihre Frage, aber Sie könnten an einigen verwandten Berechnungen interessiert sein.

Je nach Spezifikation sind uint und int immer gleich groß.

🎜🎜uint🎜 32-bit oder 64-bit 🎜🎜🎜int🎜 Gleiche Größe wie uint🎜🎜🎜Also, Wir können diese Konstante auch verwenden, um den Maximalwert eines int zu bestimmen, indem wir dieselbe Antwort nehmen, durch 2 dividieren und dann 1 subtrahieren. Das heißt: (1 << bits.UintSize) / 2 - 1🎜🎜 und der Mindestwert von int, durch Verschieben von 1 Geben Sie so viele Ziffern ein und dividieren Sie das Ergebnis durch -2. Das ist: (1 << bits.UintSize) / -2🎜🎜Kurz gesagt: 🎜🎜** MaxUint: ** (1 << bits.UintSize) - 1🎜🎜** MaxInt: ** (1 << bits.UintSize) / 2 - 1🎜🎜** MinInt: ** (1 <&lt ; Bits .UintSize) / -2🎜🎜Vollständiges Beispiel (sollte mit dem Bild unten übereinstimmen): 🎜

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

🎜Ausgabe: 🎜rrreee🎜🎜🎜Originaladresse: https://stackoverflow.com/questions/ 6878...🎜 🎜Übersetzungsadresse: https://learnku.com/go/t/62359🎜🎜

Das obige ist der detaillierte Inhalt vonEin Artikel, der den Maximalwert von Int in Go analysiert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!