La valeur maximale pour un type int en Aller

https://golang.org/ref/spec#Numeric_types pour le type physique des limites.

Les valeurs maximales sont définies dans le paquet de maths donc dans votre cas: les maths.MaxUint32

Regarder comme il n'y a aucun débordement - incrémentation dernières max causes enveloppante.

J'ai d'abord utilisé le code de la discussion thread @nmichaels utilisé dans sa réponse. J'ai maintenant un peu différent de calcul. J'ai ajouté quelques commentaires au cas où quelqu'un d'autre a la même requête que @Arijoon

const (
    MinUint uint = 0                 //binary: all zeroes

    //Perform a bitwise NOT to change every bit from 0 to 1
    MaxUint      = ^MinUint          //binary: all ones

    //Shift the binary number to the right (i.e. divide by two)
    //to change the high bit to 0
    MaxInt       = int(MaxUint >> 1) //binary: all ones except high bit

    //Perform another bitwise NOT to change the high bit to 1 and
    //all other bits to 0
    MinInt       = ^MaxInt           //binary: all zeroes except high bit
)

Les deux dernières étapes de travail en raison de combien de nombres positifs et négatifs sont représentés en complément à deux de l'arithmétique. Le langage Go de spécification de l'article sur Les types numériques renvoie le lecteur à la Article de Wikipedia. Je n'ai pas lu, mais j'ai appris à propos de complément à deux du livre Code de Charles Petzold, qui est très accessible intro les notions de base des ordinateurs et à la programmation.

J'ai mis le code ci-dessus (moins la plupart des commentaires) pour un peu de entier paquet de maths.

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
)

De fond:

Comme je suppose que vous le savez, le uint type est de la même taille que soit uint32 ou uint64, en fonction de la plateforme où vous vous trouvez. Généralement, on peut utiliser sans colle à la version de ceux-ci seulement quand il n'y a pas de risque de se rapprocher au maximum de la valeur, comme la version sans spécification de la taille peut utiliser le "natif" de type, en fonction de la plateforme, qui tend à être plus rapide.

Noter qu'il a tendance à être "plus rapide", car à l'aide d'un non-autochtone de type nécessite parfois des supplémentaires de mathématiques et de vérification de limites à être exécutées par le processeur, afin d'imiter le plus grand ou plus petit entier. Avec cela à l'esprit, sachez que les performances du processeur (ou le compilateur optimisé le code) est presque toujours va être mieux que l'ajout de vos propres limites de vérification de code, donc si il n'y a aucun risque de venir en jeu, il peut être judicieux d'utiliser simplement la taille fixe de la version, et de laisser l'optimisation de l'émulation de gérer toutes les conséquences de cela.

Avec cela dit, il existe encore des situations où il est utile de savoir ce que vous travaillez avec.

Le package "mathématiques/bits" contient la taille de uint, en bits. Pour déterminer la valeur maximale, maj 1 par le nombre de bits, moins 1. c'est à dire: (1 << bits.UintSize) - 1

Noter que lors du calcul de la valeur maximale de uint, vous aurez généralement besoin de mettre explicitement dans un uint (ou plus) de la variable, sinon le compilateur peut échouer, car il sera, par défaut, de tenter d'attribuer ce calcul dans un signé int (où, comme cela devrait être évident, il ne convient pas du tout), donc:

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

C'est la réponse directe à votre question, mais il y a aussi un couple de calculs qui pourraient vous intéresser.

Selon la spec, uint et int sont toujours de la même taille.

uint soit 32 ou 64 bits

int même taille que uint

Donc on peut aussi utiliser cette constante pour déterminer la valeur maximale de int, en prenant la même réponse et en divisant par 2 puis en soustrayant 1. c'est à dire: (1 << bits.UintSize) /2 - 1

Et la valeur minimale de int, en déplaçant 1 par le nombre de bits et en divisant le résultat par -2. c'est à dire: (1 << bits.UintSize) /-2

En résumé:

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

Exemple maxint: (1 << bits.UintSize) /2 - 1

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

exemple complet (doit être le même que ci-dessous)

package main

import "fmt"
import "math"
import "math/bits"

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