Zig 运算符

简介: Zig 运算符

运算符和表达式是编程语言中用于执行各种操作的基本组成部分。

在 Zig 中,运算符可以分为几类,包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符以及其他运算符。

以下是每种运算符的详细说明和示例。

算术运算符

运算符 描述
+ 加法
- 减法
* 乘法
/ 除法
% 取余(模运算)

实例

const std = @import("std");


pub fn main() void {

   const a: i32 = 5;

   const b: i32 = 3;

 

   const add: i32 = a + b;

   const subtract: i32 = a - b;

   const multiply: i32 = a * b;

   const divide: i32 = a / b;

   const remainder: i32 = a % b;

 

   std.debug.print("a + b = {}\n", .{add});

   std.debug.print("a - b = {}\n", .{subtract});

   std.debug.print("a * b = {}\n", .{multiply});

   std.debug.print("a / b = {}\n", .{divide});

   std.debug.print("a % b = {}\n", .{remainder});

}

编译输出结果为:

a + b = 8

a - b = 2

a * b = 15

a / b = 1

a % b = 2

关系运算符

运算符 描述
== 等于
!= 不等于
> 大于
< 小于
>= 大于等于
<= 小于等于

实例

const std = @import("std");


pub fn main() void {

   const a: i32 = 5;

   const b: i32 = 3;


   const equal: bool = a == b;

   const not_equal: bool = a != b;

   const greater: bool = a > b;

   const less: bool = a < b;

   const greater_equal: bool = a >= b;

   const less_equal: bool = a <= b;


   std.debug.print("a == b: {}\n", .{equal});

   std.debug.print("a != b: {}\n", .{not_equal});

   std.debug.print("a > b: {}\n", .{greater});

   std.debug.print("a < b: {}\n", .{less});

   std.debug.print("a >= b: {}\n", .{greater_equal});

   std.debug.print("a <= b: {}\n", .{less_equal});

}

编译输出结果为:

a == b: false

a != b: true

a > b: true

a < b: false

a >= b: true

a <= b: false

逻辑运算符

运算符 描述
and 逻辑与
or 逻辑或
! 逻辑非

实例

const std = @import("std");


pub fn main() void {

   const a: bool = true;

   const b: bool = false;


   const and_result: bool = a and b;

   const or_result: bool = a or b;

   const not_result: bool = !a;


   std.debug.print("a and b: {}\n", .{and_result}); // false

   std.debug.print("a or b: {}\n", .{or_result}); // true

   std.debug.print("!a: {}\n", .{not_result}); // false

}

编译输出结果为:

a and b: false

a or b: true

!a: false

位运算符

运算符 描述
& 按位与
| 按位或
^ 按位异或
~ 按位取反
<< 左移
>> 右移

实例

const std = @import("std");


pub fn main() void {

   const a: i32 = 5;  // 0101

   const b: i32 = 3;  // 0011


   const bit_and: i32 = a & b;      // 0001

   const bit_or: i32 = a | b;       // 0111

   const bit_xor: i32 = a ^ b;      // 0110

   const bit_not: i32 = ~a;         // 11111111111111111111111111111010

   const left_shift: i32 = a << 1;  // 1010

   const right_shift: i32 = a >> 1; // 0010


   std.debug.print("a & b: {}\n", .{bit_and});

   std.debug.print("a | b: {}\n", .{bit_or});

   std.debug.print("a ^ b: {}\n", .{bit_xor});

   std.debug.print("~a: {}\n", .{bit_not});

   std.debug.print("a << 1: {}\n", .{left_shift});

   std.debug.print("a >> 1: {}\n", .{right_shift});

}

编译输出结果为:

a & b: 1

a | b: 7

a ^ b: 6

~a: -6

a << 1: 10

a >> 1: 2

赋值运算符

运算符 描述
= 赋值
+= 加法赋值
-= 减法赋值
*= 乘法赋值
/= 除法赋值
%= 取余赋值
&= 按位与赋值
|= 按位或赋值
^= 按位异或赋值
<<= 左移赋值
>>= 右移赋值

实例

const std = @import("std");


pub fn main() void {

   var a: i32 = 5;

   const b: i32 = 3;


   a += b; // 相当于 a = a + b;

   std.debug.print("a += b: {}\n", .{a});


   a -= b; // 相当于 a = a - b;

   std.debug.print("a -= b: {}\n", .{a});


   a *= b; // 相当于 a = a * b;

   std.debug.print("a *= b: {}\n", .{a});


   a = @divTrunc(a, b); // 相当于 a = a / b;

   std.debug.print("a /= b: {}\n", .{a});


   a = @mod(a, b); // 相当于 a = a % b;

   std.debug.print("a %= b: {}\n", .{a});


   a &= b; // 相当于 a = a & b;

   std.debug.print("a &= b: {}\n", .{a});


   a |= b; // 相当于 a = a | b;

   std.debug.print("a |= b: {}\n", .{a});


   a ^= b; // 相当于 a = a ^ b;

   std.debug.print("a ^= b: {}\n", .{a});


   a <<= 1; // 相当于 a = a << 1;

   std.debug.print("a <<= 1: {}\n", .{a});


   a >>= 1; // 相当于 a = a >> 1;

   std.debug.print("a >>= 1: {}\n", .{a});

}

编译输出结果为:

a += b: 8

a -= b: 5

a *= b: 15

a /= b: 5

a %= b: 2

a &= b: 2

a |= b: 3

a ^= b: 0

a <<= 1: 0

a >>= 1: 0

其他运算符

运算符 描述
++ 自增
-- 自减

实例

const std = @import("std");


pub fn main() void {

   var a: i32 = 5;


   a += 1; // Zig 中没有 ++ 运算符,可以用 += 1 替代

   std.debug.print("a += 1: {}\n", .{a});


   a -= 1; // Zig 中没有 -- 运算符,可以用 -= 1 替代

   std.debug.print("a -= 1: {}\n", .{a});

}

编译输出结果为:

a += 1: 6

a -= 1: 5

运算符优先级

以下是 Zig 运算符的优先级列表,从高到低排列:

优先级 运算符 描述
1 () 圆括号(表达式分组)
2 [] 下标访问
3 . 成员访问
4 ! 逻辑非
~ 按位取反
- 负号
* 解引用
& 取地址
@ 内建函数调用
5 * 乘法
/ 除法
% 取余
6 + 加法
- 减法
7 << 左移
>> 右移
8 < 小于
<= 小于等于
> 大于
>= 大于等于
9 == 等于
!= 不等于
10 & 按位与
11 ^ 按位异或
12 ` `
13 and、or 逻辑与、逻辑或
14 `
15 = 赋值
+= 加法赋值
-= 减法赋值
*= 乘法赋值
/= 除法赋值
%= 取余赋值
<<= 左移赋值
>>= 右移赋值
&= 按位与赋值
^= 按位异或赋值
` =`
16 else 条件表达式

以下示例展示了运算符优先级如何影响表达式的计算顺序:

实例

const std = @import("std");


pub fn main() void {

   const a: i32 = 5;

   const b: i32 = 3;

   const c: i32 = 2;


   // 乘法优先于加法

   const result1: i32 = a + b * c; // 5 + (3 * 2) = 11

   std.debug.print("a + b * c = {}\n", .{result1});


   // 使用圆括号改变优先级

   const result2: i32 = (a + b) * c; // (5 + 3) * 2 = 16

   std.debug.print("(a + b) * c = {}\n", .{result2});


   // 比较运算符优先于逻辑运算符

   const result3: bool = a > b and b > c; // (5 > 3) and (3 > 2) = true

   std.debug.print("a > b and b > c = {}\n", .{result3});


   // 逻辑非优先于逻辑与

   const result4: bool = !(a > b) and b > c; // !(5 > 3) and (3 > 2) = false

   std.debug.print("!(a > b) and b > c = {}\n", .{result4});

}


编译输出结果为:

a + b * c = 11

(a + b) * c = 16

a > b and b > c = true

!(a > b) and b > c = false

目录
相关文章
|
7月前
|
C语言
操作符详解(3)C语言复合赋值操作符单目操作符
操作符详解(3)C语言复合赋值操作符单目操作符
|
C++
41 C++ - 运算符和结合性
41 C++ - 运算符和结合性
32 0
41 C++ - 运算符和结合性
|
存储 C语言
C语言操作符[算数操作符,赋值操作符,单目操作符,移位操作符]
C语言操作符[算数操作符,赋值操作符,单目操作符,移位操作符]
|
18天前
|
存储 CDN
Zig 数据类型
Zig 数据类型
26 2
|
14天前
|
编译器
Zig 函数
Zig 函数
23 1
|
7月前
|
C++
在C++语言中自增自减运算符
在C++语言中自增自减运算符
64 0
|
7月前
|
存储 C语言
C learning_12 操作符前篇(算术操作符、移位操作符、位操作符、赋值操作符、单目操作符、关系操作符、逻辑操作符)
C learning_12 操作符前篇(算术操作符、移位操作符、位操作符、赋值操作符、单目操作符、关系操作符、逻辑操作符)
|
编译器 C语言
易错的运算符
易错的运算符
|
Rust JavaScript 前端开发
Zig
Zig 是一门系统编程语言,旨在提供一种简单、安全且高效的方式来构建软件。它的设计受到了 Rust、C 和 C++ 的影响,但与这些语言相比,Zig 更加简单易用。Zig 的语法和抽象级别使得它易于学习和使用,同时它还提供了许多现代编程语言的功能,如高级类型、模块化编程和内存安全等。
263 6