算数运算符
| 运算符 |
描述 |
实例 |
| + |
相加 |
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语言中++、–运算符不支持前置
- 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)
}
关系算符
| 运算符 |
描述 |
实例 |
| == |
检查两个值是否相等，如果相等返回 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
逻辑运算符
| 运算符 |
描述 |
实例 |
| && |
如果两边的操作数都是 True，则条件 True，否则为 False。 |
A && B |
| \|\| |
如果两边的操作数有一个 True，则条件 True，否则为 False。 |
A || B |
| ! |
如果条件为 True，则逻辑 NOT 条件 False，否则为 True。 |
!A |
- 注意点:
- 和C语言不通的是, Go语言中关系运算符只能返回true和false
- 逻辑非只能用于true和false
位运算符
运算符描述实例&参与运算的两数各对应的二进位相与, 对应位只要都是1结果就为1A & B\|参与运算的两数各对应的二进位相或,对应位只要其中一个是1结果就为1A | B^参与运算的两数各对应的二进位相异或,对应位只要不同结果就是1A ^ 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 = 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)) // 编译报错
}
运算符优先级
到此这
算数运算符
| 运算符 |
描述 |
实例 |
| + |
相加 |
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语言中++、–运算符不支持前置
- 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)
}
关系算符
| 运算符 |
描述 |
实例 |
| == |
检查两个值是否相等，如果相等返回 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
逻辑运算符
| 运算符 |
描述 |
实例 |
| && |
如果两边的操作数都是 True，则条件 True，否则为 False。 |
A && B |
| \|\| |
如果两边的操作数有一个 True，则条件 True，否则为 False。 |
A || B |
| ! |
如果条件为 True，则逻辑 NOT 条件 False，否则为 True。 |
!A |
- 注意点:
- 和C语言不通的是, Go语言中关系运算符只能返回true和false
- 逻辑非只能用于true和false
位运算符
运算符描述实例&参与运算的两数各对应的二进位相与, 对应位只要都是1结果就为1A & B\|参与运算的两数各对应的二进位相或,对应位只要其中一个是1结果就为1A | B^参与运算的两数各对应的二进位相异或,对应位只要不同结果就是1A ^ 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 = 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)) // 编译报错
}
运算符优先级
到此这Go语言
