Home / Questions / 4902
Accepted
Gepser Hoil
Asked: 2020-02-28 18:27:22 +0800 CST 2020-02-28 18:27:22 +0800 CST

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

  • 772

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

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

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

go

2 Answers

  1. Best Answer

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

    • <<добавит столько битов (со значением 0) справа от числа, сколько указано значением, которое идет после оператора. Или то же самое: все биты числа будут смещены влево на заданное количество позиций.

      И поскольку картинка стоит тысячи слов, вот графическое объяснение, созданное CBurnett (источник: Википедия )

      Изображение из Википедии, созданное Cburnett

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

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

      введите описание изображения здесь

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

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

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

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

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

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

    Таким образом, в случае, который вы приводите в качестве примера:

    • Big= 1 * 2 100 = 1 267 650 600 228 229 401 496 703 205 376 (переполнение целых чисел).
    • Small= Big* 2 -99 = 2 100 * 2 -99 = 2 1 = 2.
    • 10

  2. Операторы << и >> определены как арифметические операторы в языке GO , они определены как операторы сдвига битов:

    • << Оператор сдвига влево.

    • >> Оператор сдвига правого бита.

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

    Например, каково будет значение 1011 0011в десятичном формате? Ну а по его расположению справа налево имеем:

    введите описание изображения здесь

    Следовательно, он 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 .

    • 6