Go <> opérateurs

Quelqu’un pourrait-il m’expliquer l’utilisation de << et >> dans Go? Je suppose que c’est similaire à d’autres langues.

D’après les spécifications de http://golang.org/doc/go_spec.html , il semble qu’au moins avec des nombres entiers, c’est un décalage binary. par exemple, 0b00001000 binary >> 1 serait 0b00000100 et 0b00001000 << 1 serait 0b00010000.


Go n’accepte apparemment pas la notation 0b pour les entiers binarys. Je l’utilisais juste pour l’exemple. En décimal, 8 >> 1 vaut 4, et 8 << 1 vaut 16. Le décalage laissé par un est le même que la multiplication par 2, et le décalage vers la droite est identique à la division par deux, supprimant tout reste.

La définition simplifiée super (éventuellement sur) est juste que << est utilisé pour "times 2" et >> est pour "divisé par 2" - et le nombre après c'est combien de fois.

Donc n << x est "n fois 2, x fois". Et y >> z est "y divisé par 2, z fois".

Par exemple, 1 << 5 correspond à "1 fois 2, 5 fois" ou 32. Et 32 >> 5 correspond à "32 divisé par 2, 5 fois" ou 1.

Toutes les autres réponses donnent une définition plus technique, mais personne ne l'a dit franchement et je pensais que vous pourriez le vouloir.

Les opérateurs << et >> sont des opérateurs arithmétiques Go .

 << left shift integer << unsigned integer >> right shift integer >> unsigned integer 

Les opérateurs de décalage déplacent l’opérande gauche par le compte de décalage spécifié par l’opérande droit. Ils implémentent des décalages arithmétiques si l’opérande gauche est un entier signé et des décalages logiques s’il s’agit d’un entier non signé. Le compte de décalage doit être un entier non signé. Il n’y a pas de limite supérieure pour le nombre de quarts de travail. Les décalages se comportent comme si l’opérande gauche était décalé de 1 fois par 1 pour un compte de décalage de n. En conséquence, x << 1 est identique à x * 2 et x >> 1 est identique à x / 2 mais tronqué vers l’infini négatif.

Ce sont essentiellement des opérateurs arithmétiques et la même chose dans les autres langages est un exemple de base PHP, C, Go

ALLER

 package main import ( "fmt" ) func main() { var t , i uint t , i = 1 , 1 for i = 1 ; i < 10 ; i++ { fmt.Printf("%d << %d = %d \n", t , i , t<> %d = %d \n", t , i , t>>i) } } 

Démo GO

C

 #include  int main() { int t = 1 ; int i = 1 ; for(i = 1; i < 10; i++) { printf("%d << %d = %d \n", t, i, t << i); } printf("\n"); t = 512; for(i = 1; i < 10; i++) { printf("%d >> %d = %d \n", t, i, t >> i); } return 0; } 

C Demo

PHP

 $t = $i = 1; for($i = 1; $i < 10; $i++) { printf("%d << %d = %d \n", $t, $i, $t << $i); } print PHP_EOL; $t = 512; for($i = 1; $i < 10; $i++) { printf("%d >> %d = %d \n", $t, $i, $t >> $i); } 

Démo PHP

Ils sortiraient tous

 1 << 1 = 2 1 << 2 = 4 1 << 3 = 8 1 << 4 = 16 1 << 5 = 32 1 << 6 = 64 1 << 7 = 128 1 << 8 = 256 1 << 9 = 512 512 >> 1 = 256 512 >> 2 = 128 512 >> 3 = 64 512 >> 4 = 32 512 >> 5 = 16 512 >> 6 = 8 512 >> 7 = 4 512 >> 8 = 2 512 >> 9 = 1 

<< est à gauche. >> est un décalage vers la droite lorsque l'opérande gauche est un entier signé, et s'étend à zéro lorsque l'opérande gauche est un entier non signé.

Pour mieux comprendre >> pense à

 var u uint32 = 0x80000000; var i int32 = -2; u >> 1; // Is 0x40000000 similar to >>> in Java i >> 1; // Is -1 similar to >> in Java 

Donc, lorsqu'il est appliqué à un entier non signé, les bits à gauche sont remplis avec zéro, alors que, lorsqu'ils sont appliqués à un entier signé, les bits à gauche sont remplis avec le bit le plus à gauche (1 lorsque l'entier signé est négatif à 2). complément).

Go “et” sont similaires aux décalages (c’est-à-dire: division ou multiplication par une puissance de 2) dans d’autres langages, mais parce que Go est un langage plus sûr que C / C ++, il fait un peu de travail .

Les instructions de décalage dans les processeurs x86 ne prennent en compte que 5 bits (6 bits sur les CPU x86 64 bits) du nombre de shift. Dans des langages comme C / C ++, l’opérateur de décalage se traduit par une seule instruction de processeur.

Le code Go suivant

 x := 10 y := uint(1025) // A big shift count println(x >> y) println(x << y) 

estampes

 0 0 

alors qu'un programme C / C ++ s'imprimerait

 5 20 

En mathématiques décimales , lorsque nous multiplions ou divisons par 10 , nous effectuons les zéros à la fin du nombre.

En binary , 2 a le même effet. Donc, nous ajoutons un zéro à la fin, ou en supprimant le dernier chiffre