Что значит>> и <<в Go?

Я изучаю Go (golang) и я столкнулся с тем, что я не понимаю этот синтаксис в заявлении переменных или постоянных величин. Например:

const (
    Big   = 1 << 100
    Small = Big >> 99
)

Что это значит точно?

8
задан 08.03.2016, 16:17
2 ответа

Операторы << и >> они - операторы перемещения бита и только могут применяться к целым числам:

  • << добавил бы столькие бит (со стоимостью 0) справа от числа как было показано в стоимости, что приходит trás оператор. Или то, что является тем же самым: все биты числа переместили бы в левую сторону столькие положение, как он был определен.

    И как изображение стоит больше, чем тысяча слов, здесь я оставляю графическое объяснение, созданное CBurnett (шрифт: Wikipedia)

    Imagen de la Wikipedia creada por Cburnett

  • >> он удалил бы столько бит справа от числа, как было показано в стоимости, что он приходит за оператором. Или то, что является тем же самым: биты числа переместили бы в правую сторону столько положений, как он был определен (будучи отсечен равное число раз).

    Другое графическое объяснение, созданное Cburnett (шрифт: Wikipedia)

    introducir la descripción de la imagen aquí

Согласно документации Go по арифметическим операторам:

The shift operators shift the left operand by the shift count specified by the right operand. They implement arithmetic shifts if the left operand is в signed integer and logical shifts if it is an unsigned integer. There is не upper limit on the shift count. Shifts behave эксперт if the left operand is shifted n укради by 1 for в shift count of n. Схвати в result, x <<1 is the same эксперт x*2 and x>> 1 is the same эксперт x/2 but truncated towards negative infinity.

И перевод на испанский язык (что-то освободите, я надеюсь, что понимают):

Операторы перемещения прокручивают действуя левой стороны так часто, как будьте показан в действуя правой стороны. Они осуществляют арифметическое перемещение, если действуя левой стороны это целое число со знаком, и логическое перемещение, если это целое число без знака. Нет предела относительно стоимости перемещений, которую нужно реализовывать. Перемещения ведут себя как будто действуя левой стороны он прокручен n разы 1 из-за каждого перемещения n. Как результат, x <<1 - то же самое что x*2 и x>> 1 - то же самое что x/2, но отсеченный до отрицательной бесконечности.


Эта последняя часть очень важна, потому что он позволяет создавать формулу, которую страховка помогает понимать лучше, что является тем, что они делают:

  • Оператор n << m он эквивалентный в "n умноженный на 2, м разы" = n * 2m.
  • Оператор n >> m он эквивалентный в "n разделенный по 2, м разы" = n * 2 - м.

Так, в случае, который ты помещаешь, примера:

  • Big = 1 * 2100 = 1.267.650.600.228.229.401.496.703.205.376 (он превышает целые числа).
  • Small = Big * 2-99 = 2100 * 2-99 = 21 = 2.
10
ответ дан 24.11.2019, 14:48
  • 1
    представляло себе, что он был бы сходным с другими языками, но из-за любопытства между, хорошее объяснение. Привет. – Angel Angel 28.02.2016, 12:32
  • 2
    с другой стороны, равный было бы возможно помещать что-либо подобное, чтобы доводить до сведения, что они теряются бит, если например: Бит, который они выходят из реестра из-за конца, они теряются и в другом конце реестра объедается с битом нуль из-за каждого перемещённого бита. ej: Если по отношению к себе имеет в реестре 8 бит стоимость 10110011, и делается перемещение к левой стороне бита все биты двигают posici и # 243; n к левой стороне, бит лев. теряется и вводит бит нуль наполнения из-за правой стороны. (к der. происходит что-то похожее), бит der. теряется, бит лев. объедается с 0 – Angel Angel 28.02.2016, 12:39
  • 3
    Действительно, идея сходная с оставшейся частью языков programaci и # 243; n. Хотя не s и # 233; если expliqu и # 233; лучшего способа – Alvaro Montoro♦ 28.02.2016, 15:01
  • 4
    в меня лично, я верю в то, что если, кроме детали помещения - > Big = 1 * 2100...., так как без этого разъяснения может казаться в каком-то случае, что верят в то, что Big = 1 < < 100 то, что он делает, состоит в том, чтобы помещать что-либо подобное 100 в Big, на уровне целого числа, поэтому я думаю, что пример разъясняет больше, что он на уровне бита (каждый бит 2 состояния), Привете – Angel Angel 28.02.2016, 15:25

Операторы <<y>> определены как арифметические операторы внутри языка GO, определяются как операторы перемещения бита:

  • <<оператор перемещения бита в левую сторону.

  • >> оператор перемещения бита в правую сторону.

Перед тем, как начинать объяснять, как функционируют операторы и перемещение бит в бит, давайте помнить, как мы получаем десятичную стоимость начиная с бинарного числа.

например: каковой была бы стоимость 1011 0011 в десятичном? Хорошо, согласно Вашему положению правой стороны в левую сторону мы имеем:

introducir la descripción de la imagen aquí

Следовательно, 1011 0011 он равен в 179 в десятичном

Очень важно комментировать, что этот оператор существует в других языках кроме GO, как они: Java, php, C, C#, и т.д.

Простой пример, чтобы объяснять, поскольку оно функционирует, оператор перемещения бита в левую сторону, был бы:

3 << 2 стоимость которого оказывается 12, объяснение:

3 в бинарном он 0011 операция показывает перемещение бита в 2 положениях к левой стороне, следовательно: 1100 что в бинарном оказывается 12

Если мы реализуем обратную операцию:

12 >> 2 результат которого 3; 12 в бинарном он 1100, если мы реализуем перемещение бит к правой стороне 2 положения, мы получаем 0011 что в десятичном 3.

Это пример в языке Go, где ты можешь видеть как начиная со стоимости 1 (Стоимость в бинарном: 0001) реализовав перемещение бит к левой стороне, Ваша стоимость меняется:

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

это был бы вывод:

1 << 1 = 2     (Valor en binario: 0010) 
1 << 2 = 4     (Valor en binario: 0100)
1 << 3 = 8     (Valor en binario: 1000) 
1 << 4 = 16    (Valor en binario: 1 0000) 
1 << 5 = 32    (Valor en binario: 10 0000) 
1 << 6 = 64    (Valor en binario: 100 0000) 
1 << 7 = 128   (Valor en binario: 1000 0000)
1 << 8 = 256   (Valor en binario: 1 0000 0000) 
1 << 9  = 512  (Valor en binario: 10 0000 0000)

Сейчас пример в языке Go осуществляя сдвиг бит к правой стороне:

package main    
import "fmt"

func main() {

    var t , i uint
    t , i = 1024 , 1

    for i = 1 ; i < 10 ; i++ {
        fmt.Printf("%d >> %d = %d \n", t , i , t>>i)
    }    
}

Выход:

1024 >> 1 = 512  (Valor en binario: 10 0000 0000)
1024 >> 2 = 256  (Valor en binario: 1 0000 0000) 
1024 >> 3 = 128  (Valor en binario: 1000 0000)
1024 >> 4 = 64   (Valor en binario: 100 0000) 
1024 >> 5 = 32   (Valor en binario: 10 0000) 
1024 >> 6 = 16   (Valor en binario: 1 0000) 
1024 >> 7 = 8    (Valor en binario: 1000) 
1024 >> 8 = 4    (Valor en binario: 0100)
1024 >> 9 = 2    (Valor en binario: 0010) 

Больше информации: https://golang.org/ref/spec#Arithmetic_operators

7
ответ дан 24.11.2019, 14:48

Теги

Похожие вопросы