当前位置： YY全王模板 > 未命名 > Go语言运算符案例讲解

Go语言运算符案例讲解

作者：administrator 时间：22-11-25 阅读数：213人阅读

算数运算符

  • 算数运算符和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结果就为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语言几乎一样
    • 新增一个&^=运算符
运算符 描述 实例
= 将右边赋值给左边 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语言一样, 只需记住()优先级最高即可

到此这

算数运算符

  • 算数运算符和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结果就为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语言几乎一样
    • 新增一个&^=运算符
运算符 描述 实例
= 将右边赋值给左边 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语言一样, 只需记住()优先级最高即可

到此这Go语言

收藏
点赞

上一篇：Go语言指针使用分析与讲解

下一篇：Go 协程超时控制的实现

相关文章