算数运算符

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

注意点:

1. 不同类型的常量(字面量)可以进行运算
2. 不同类型的变量不可以直接进行运算

res1 := 10 / 3.0
var num1 int  = 10
var num2 float64 = 3.0
//var res1 float64 = num1 / num2 // 报错
var res1 float64 = float64(num1) / num2
fmt.Println(res1)

3. '+' 还可以用于拼接字符串, 并且只有相同类型才能进行运算

var str1 string = "l23"
var str2 string = "666"
var res2 string = str1 + str2
fmt.Println(res2) // 123666

// 只有相同类型才能进行运算
var res3 string = "123" + 6 // 会报错
fmt.Println(res3)

4. Go语言中的++ -- 只能写在后面, 不能写在前面

num := 1
fmt.Println(num) // 1
num++ // num = num + 1
fmt.Println(num) // 2
num-- // num = num - 1
fmt.Println(num) // 1

++num // 报错
--num // 报错

关系运算符

• 关系运算符和C语言一样

注意点:

1. 在C语言中非零即真, 但是在Go语言中没有非零即真的概念
2. Go语言中所有的关系运算符返回的都是true或者false

关系运算符的优先级, 只需要记住()最高即可

res1 := 10 > 5
fmt.Println(res1) // true
res2 := 10 < 5
fmt.Println(res2) // false
res3 := 10 >= 5
fmt.Println(res3) // true
res4 := 10 <= 5
fmt.Println(res4) // false
res5 := 10 == 10
fmt.Println(res5) // true
res6 := 10 != 10
fmt.Println(res6) // false

逻辑运算符

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

注意点:

1. Go语言中的逻辑运算符返回的是true和false
2. 参与运算的表达式的返回值都必须是布尔类型才行
   表达式1 && 表达式2
   表达式1 || 表达式2
   !表达式

规则:
&& 一假则假
|| 一真则真
! 真变假假变真

int main(){

     res1 := (10 > 5) && (1 > 1)
     //res1 := 1 && 1 // 报错, 没有非零即真的概念, &&两边必须都是布尔类型
     fmt.Println(res1) // false

    res2 := (10 > 5) || (1 > 1)
    //res2 := 1 || 1 // 报错, 没有非零即真的概念, ||两边必须都是布尔类型
    fmt.Println(res2) // true

    //res3 := !false
    //res3 := !0 // 报错, 没有非零即真的概念, !右边必须是布尔类型
    res3 := !(10 > 5)
    fmt.Println(res3) // false
}

位运算符

• 位运算符和C语言几乎一样(多了一个 &^ 运算符)

• 位运算是专门用于计算二进制位的
  & 一假则假
  | 一真则真
  ^ 不同为真, 相同为假
  << 乘以2的左移多少次幂
  '>>' 除以2的右移多次次幂

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语言几乎一样(新增一个&^=运算符)

其它运算符

var num int
num = 10
// 定义一个指向int类型变量的指针
var p *int
// 取出num变量的内存地址, 放到指针变量p中
p = &num
// 访问指针指向的内存
fmt.Println(*p)

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

fmt.Println(*p)
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语言一样, 只需记住()优先级最高即可