go语言运算符%3c-,Go语言运算符

算数运算符

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

运算符

描述

实例

+

相加

A + B

-

相减

A - B

*

相乘

A * B

/

相除

B / A

%

求余

B % A

++

自增

A++

--

自减

A--

注意点:

不同类型的常量(字面量)可以进行运算

不同类型的变量不可以直接进行运算

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)

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

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)

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语言一样

运算符

描述

实例

==

检查两个值是否相等，如果相等返回 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语言中没有非零即真的概念

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语言一样

运算符

描述

实例

&&

如果两边的操作数都是 True，则条件 True，否则为 False

A && B

II

如果两边的操作数有一个 True，则条件 True，否则为 False

A II B

!

如果条件为 True，则逻辑 NOT 条件 False，否则为 True

!A

注意点:

Go语言中的逻辑运算符返回的是true和false

参与运算的表达式的返回值都必须是布尔类型才行

表达式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语言几乎一样(多了一个 &^ 运算符)

运算符

描述

实例

&

参与运算的两数各对应的二进位相与, 对应位只要都是1结果就为1

A & B

I

参与运算的两数各对应的二进位相或,对应位只要其中一个是1结果就为1

A I B

^

参与运算的两数各对应的二进位相异或,对应位只要不同结果就是1

A ^ B

<<

左移运算符,左移n位就是乘以2的n次方

A << 2

>>

右移运算符,右移n位就是除以2的n次方

B >> 2

&^

逻辑清零运算符, B对应位是1,A对应位清零,B对应位是0, A对应位保留原样

A &^ B

位运算是专门用于计算二进制位的

& 一假则假

| 一真则真

^ 不同为真, 相同为假

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

运算符

描述

实例

=

将右边赋值给左边

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

I=

位逻辑异或赋值

C I= 2 等于 C = C I 2

&^=

位逻辑清零赋值

C &^= 2 等于 C = C &^ 2

其它运算符

运算符

描述

实例

&

返回变量存储地址

&a; 将给出变量的实际地址

*

访问指针指向内存

*p; 访问指针p指向内存

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