Pourquoi Golang génère-t-il une erreur de débordement lors du calcul des constantes ?

Comprendre le débordement constant de Golang avec uint64

Problème :

Considérez le code Golang suivant :

<code class="go">userid := 12345
did := (userid & ^(0xFFFF << 48))</code>

Lors de la tentative de compilation de ce code, une erreur est rencontrée :

./xxxx.go:511: constant -18446462598732840961 overflows int

Analyse :

Le nœud de ce problème réside dans la constante non typée ^(0xFFFF << 48). Cette constante représente une valeur très importante en raison de l'opération de décalage. Lorsque la constante non typée est convertie en int en raison de l'opération au niveau du bit avec l'ID utilisateur, le compilateur génère une erreur de débordement car la constante dépasse la valeur maximale pouvant être représentée par un int.

Solution :

Pour résoudre ce problème, on peut explicitement convertir la constante non typée en un type qui peut s'adapter à sa grande ampleur. Par exemple, on peut remplacer l'expression problématique par ce qui suit :

<code class="go">did := (userid & (1<<48 - 1))</code>

Dans cette expression modifiée, 1<<48 - 1 donne la constante 0x0000ffffffffffff, qui peut être représentée par un type de données int64. Alternativement, on peut utiliser explicitement int64 dans le code pour garantir la compatibilité avec les architectures 32 bits et 64 bits :

<code class="go">func main() {
  const userID int64 = 12345
  did := userID & (1<<48 - 1)
  println(did)
}</code>

En adhérant à ces suggestions, vous pouvez gérer efficacement les débordements constants dans Golang et maintenir le code portabilité sur différentes architectures.

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!