08-Go语言运算符-指趣学院

算数运算符

• 算数运算符和C语言几乎一样

运算符	描述	实例
+	相加	A + B
-	相减	A - B
*	相乘	A * B
/	相除	B / A
%	求余	B % A
++	自增	A++
--	自减	A--

• 注意点:
  • 只有相同类型的数据才能进行运算

package main
import "fmt"
int main(){
    var num1 int32 = 10
    //var num2 int64 = num1 // 类型不同不能进行赋值运算
    var num2 int64 = int64(num1) // 类型不同不能进行赋值运算
    fmt.Println(num2)

    var num3 int32 = 10
    var num4 int64 = 20
    //var res int64 = num3 + num4 // 类型不同不能进行算数运算
    var res1 int64 = int64(num3) + num4 // 类型不同不能进行算数运算
    fmt.Println(res1)

    var num5 int32 = 10
    var num6 int64 = 20
    //var res2 bool = (num5 == num6) // 类型不同不能进行关系运算
    var res2 bool = (num5 == int32(num6)) // 类型不同不能进行关系运算
    fmt.Println(res2)

    // ... ... 其它以此类推
}

• Go语言中++、--运算符不支持前置
  • 错误写法: ++i; --i;
• Go语言中++、--是语句,不是表达式,所以必须独占一行
  • 错误写法: a = i++; return i++;

package main
import "fmt"
func main() {
    num1 := 0
    num1++
    fmt.Println(num1)
    //++num1 // 编译报错, Go语言中++只能后置,不能前置
    //fmt.Println(num1)
    //var num2 int = num1++ // 编译报错, num1++是语句不是表达式, 所以必须独占一行
    //fmt.Println(num2)
}

• Go语言中字符串支持利用+号进行拼接

package main
import "fmt"
func main() {
    str := "abc" + "def"
    //fmt.Println(str)
}

---

关系算符

• 关系算符和C语言一样

运算符	描述	实例
==	检查两个值是否相等，如果相等返回 True 否则返回 False。	A == B
!=	检查两个值是否不相等，如果不相等返回 True 否则返回 False。	A != B
>	检查左边值是否大于右边值，如果是返回 True 否则返回 False。	A > B
<	检查左边值是否小于右边值，如果是返回 True 否则返回 False。	A < B
>=	检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。	A >= B
<=	检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。	A <= B

• 注意点:
  • 和C语言不通的是, Go语言中关系运算符只能返回true和false

---

逻辑运算符

• 逻辑运算符和C语言一样

运算符	描述	实例
&&	如果两边的操作数都是 True，则条件 True，否则为 False。	A && B
||	如果两边的操作数有一个 True，则条件 True，否则为 False。	A || B
!	如果条件为 True，则逻辑 NOT 条件 False，否则为 True。	!A

• 注意点:
  • 和C语言不通的是, Go语言中关系运算符只能返回true和false
  • 逻辑非只能用于true和false

---

位运算符

• 位运算符和C语言几乎一样

运算符	描述	实例
&	参与运算的两数各对应的二进位相与, 对应位只要都是1结果就为1	A & B
|	参与运算的两数各对应的二进位相或,对应位只要其中一个是1结果就为1	A | B
^	参与运算的两数各对应的二进位相异或,对应位只要不同结果就是1	A ^ B
<<	左移运算符,左移n位就是乘以2的n次方	A << 2
>>	右移运算符,右移n位就是除以2的n次方	B >> 2
&^	逻辑清零运算符, B对应位是1,A对应位清零,B对应位是0, A对应位保留原样	A &^ B

• 新增一个&^运算符

int main(){
    /*
      0110      a
    &^1011      b 如果b位位1,那么结果为0, 否则结果为a位对应的值
    ----------
      0100
    */
    a1 := 6
    b1 := 11
    res1 := a1 &^ b1
    fmt.Println("res1 = ", res1) // 4

    /*
      1011      a
    &^1101      b 如果b位位1,那么结果为0, 否则结果为a位对应的值
    ----------
      0010
    */
    a2 := 11
    b2 := 13
    res2 := a2 &^ b2
    fmt.Println("res2 = ", res2) // 2
}

---

赋值运算符

• 赋值运算符和C语言几乎一样
  • 新增一个&^=运算符

运算符	描述	实例
=	将右边赋值给左边	C = A + B 将 A + B 表达式结果赋值给 C
+=	相加后再赋值	C += A 等于 C = C + A
-=	相减后再赋值	C -= A 等于 C = C - A
*=	相乘后再赋值	C *= A 等于 C = C * A
/=	相除后再赋值	C /= A 等于 C = C / A
%=	求余后再赋值	C %= A 等于 C = C % A
<<=	左移赋值	C <<= 2 等于 C = C << 2
>>=	右移赋值	C >>= 2 等于 C = C >> 2
&=	位逻辑与赋值	C &= 2 等于 C = C & 2
^=	位逻辑或赋值	C ^= 2 等于 C = C ^ 2
|=	位逻辑异或赋值	C |= 2 等于 C = C | 2
&^=	位逻辑清零赋值	C &^= 2 等于 C = C &^ 2

---

其它运算符

运算符	描述	实例
&	返回变量存储地址	&a; 将给出变量的实际地址
*	访问指针指向内存	*p; 访问指针p指向内存

package main
import "fmt"
int main(){
    var num int = 666
    var p *int = &num
    fmt.Println(num)
    fmt.Println(*p)
    num = 777
    fmt.Println(num)
    *p = 999
    fmt.Println(num)
}

• 注意点
  • 指针类型只支持相等运算, 不能做加减运算

#include <stdio.h>
int main()
{
    int ages[3] = {19, 23, 22};
    int *arrayP = &ages[0];
    printf("ages[0] = %i\n", *(arrayP + 0)); // *(arrayP + 0) == *arrayP
    printf("ages[1] = %i\n", *(arrayP + 1));
    printf("ages[2] = %i\n", *(arrayP + 2));
    return 0;
}

package main
import "fmt"
int main(){
    var ages [3]int = [3]int{19, 23, 22}
    var p *int = &ages[0]
    //fmt.Println(&ages[0])
    //fmt.Println(*p) // 19
    fmt.Println(*(p + 0)) // 编译报错
}

运算符优先级

• 和C语言一样, 只需记住()优先级最高即可