Go 围棋<&书信电报；及>&燃气轮机；操作员

有人能给我解释一下围棋中

的用法吗？我猜它与其他一些语言类似。

从at的规范来看，似乎至少对于整数来说，它是一个二进制移位。例如，二进制0b00001000>>1将是0b00000100，而0b00001000运算符是

右移整数>>无符号整数

换档操纵员向左换档 按指定的移位计数计算操作数 按右操作数。他们实施 如果左操作数 是有符号整数和逻辑移位 如果它是无符号整数。这个 移位计数必须是无符号的 整数。这个数字没有上限 轮班计数。轮班的行为就好像 左操作数移位n次 1表示n的移位计数。因此， x>1 与x/2相同，但被截断 朝向负无穷远

在左操作数为有符号整数时为符号扩展右移位，在左操作数为无符号整数时为零扩展右移位

要更好地理解

>

请考虑

var u uint32 = 0x80000000;
var i int32 = -2;

u >> 1;  // Is 0x40000000 similar to >>> in Java
i >> 1;  // Is -1 similar to >> in Java

因此，当应用于无符号整数时，左边的位用零填充，而当应用于有符号整数时，左边的位用最左边的位填充（当有符号整数按2的补码为负数时，为1）。

Go>类似于移位（即：除以或乘以2的幂）在其他语言中，但由于Go是一种比C/C++更安全的语言，因此当移位计数为一个数字时，它会做一些额外的工作

下面的Go代码

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

而C/C++程序会打印

5
20

它们基本上是相同的，在其他语言中也是一样的。这里是一个基本的PHP、C、Go示例

开始

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


    fmt.Println()

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

}

#include <stdio.h>
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;
}

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 

主程序包
进口(
“fmt”
)
func main（）{
变量t，i uint
t，i=1，1
对于i=1；i<10；i++{
fmt.Printf（“%d>%d=%d\n”，t，i，t>>i）
}
}

C

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


    fmt.Println()

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

}

#include <stdio.h>
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;
}

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 

#包括
int main（）
{
int t=1；
int i=1；
对于（i=1；i<10；i++）{
printf（“%d>%d=%d\n”，t，i，t>>i）；
}    
返回0；
}

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

$t=$i=1；
对于（$i=1；$i<10；$i++）{
printf（“%d>%d=%d\n”，$t$i，$t>>i）；
}

他们都会输出

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


    fmt.Println()

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

}

#include <stdio.h>
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;
}

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 

1>5=16
512 >> 6 = 8 
512 >> 7 = 4 
512 >> 8 = 2 
512 >> 9 = 1 

超级（可能过度）简化的定义是，

用于“除以2”-后面的数字是多少次

所以

n>z

是“y除以2，z的次数”

例如，

1>5

是“32除以2，5次”或1

---

所有其他答案都给出了更为技术性的定义，但没有人直截了当地给出，我想你可能会想要这样。

在十进制数学中，当我们乘以或除以10时，我们会影响数字末尾的零

---

在二进制中，2具有相同的效果。因此，我们在末尾添加一个零，或者删除最后一个数字，这些是右位运算符和左位运算符

var shift uint64
shift = uint64(1) << 52
fmt.Printf("shift %d\n", shift)

班次4503599627370496

---

似乎是错误的。< /P>对于C和C++移位运算符，“如果右操作数为负，或者大于或等于提升左操作数的位长，则行为未定义。”C和C++标准不能保证C和C++程序将打印5和20。@彼得索：是的，你是对的。我的观点是，每个编程语言标准都必须在一个具体的CPU上有一个具体的实现。在单个CPU系列（x86-32）的上下文中，所有C/C++编译器的行为（可以预期）是相同的。这是因为，当上下文没有告诉它任何关于“x”和“y”的信息时，只发出1条SHL/SHR/etc指令来实现移位运算符是优化C/C++编译器所能做的最好的事情。而且，如果编译器知道代码有未定义的行为，它应该通知用户。我不同意。您应该编写可移植代码。Linux和Windows都在ARM上运行。专注于单一CPU系列是短视的。此外，y是一个变量。事实上，编译器不知道它的实际运行时值。@Atom除了对将发生的事情提供绝对没有保证的语言之外，如果您更改编译选项（例如优化的构建），即使在使用单个编译器的单个计算机上，未定义的行为也可能会有所不同。在我看来，以任何方式依赖它都是危险的错误。@Anonymous是的，但这只是理论。您能否提供一个具体的例子，说明在C/C++中更改编译选项会导致

的不同行为？回答得很好。当我在处理2的幂的代码中看到这一点时，这是非常有意义的（1我认为这是完整的等式：（x>n==x*2^（-n））回答很好，一开始二进制移位似乎很麻烦，但将值转换为十进制，并将幂次转换为2有助于很好地得到它。这是一个很好的答案。这在我的脑海中真的凝固了它，谢谢。这是答案应该是这样的。