Zig 运算符

作者likuolei

在 Zig 编程语言中，运算符（Operators）是用于执行计算、比较和逻辑操作的符号。Zig 的运算符设计简洁、显式，遵循类型安全原则，避免了 C/C++ 中常见的隐式行为和未定义行为。以下是对 Zig 运算符的中文讲解，涵盖算术、比较、逻辑、位操作、赋值、特殊运算符及注意事项，基于 Zig 0.14.1（截至 2025 年 5 月的稳定版），力求简洁清晰。

1. Zig 运算符概述

Zig 的运算符用于操作变量和值，特点包括：

  • 类型安全：运算符要求操作数类型匹配，无隐式类型转换。
  • 显式性：不支持操作符重载，确保行为可预测。
  • 性能优化：运算符直接映射到机器指令，效率高。
  • 错误检查：内置溢出检查（如加法 +%），防止未定义行为。

Zig 运算符分为以下几类：

  • 算术运算符
  • 比较运算符
  • 逻辑运算符
  • 位运算符
  • 赋值运算符
  • 特殊运算符（如错误处理、可选类型）

2. 算术运算符

用于执行数学运算，支持整数和浮点数。

运算符列表

  • +：加法
  • -：减法
  • *：乘法
  • /：除法（整数除法舍去小数）
  • %：取模（仅整数）
  • **：幂运算（编译时支持）

示例

const std = @import("std");

pub fn main() !void {
    const a: i32 = 10;
    const b: i32 = 3;
    const stdout = std.io.getStdOut().writer();

    try stdout.print("加: {}\n", .{a + b});  // 13
    try stdout.print("减: {}\n", .{a - b});  // 7
    try stdout.print("乘: {}\n", .{a * b});  // 30
    try stdout.print("除: {}\n", .{a / b});  // 3
    try stdout.print("模: {}\n", .{a % b});  // 1

    const c: f32 = 2.0;
    try stdout.print("幂: {}\n", .{std.math.pow(f32, c, 3.0)}); // 8.0
}

说明：

  • 整数除法（/）舍去小数部分。
  • 浮点数运算需使用 std.math 提供的函数（如 pow）。
  • 类型必须匹配：
  const x: i32 = 10;
  const y: f32 = 2.0;
  // x + y; // 错误：类型不匹配

溢出检查

Zig 默认检查整数运算溢出，抛出运行时错误。可使用以下运算符禁用检查：

  • +%：加法，溢出环绕。
  • -%：减法，溢出环绕。
  • *%：乘法，溢出环绕。

示例：

var x: u8 = 255;
x = x +% 1; // 环绕到 0
try std.io.getStdOut().writer().print("溢出: {}\n", .{x}); // 输出：0

3. 比较运算符

用于比较两个值，返回 bool 类型。

运算符列表

  • ==：等于
  • !=：不等于
  • <：小于
  • >：大于
  • <=：小于等于
  • >=：大于等于

示例

const std = @import("std");

pub fn main() !void {
    const a: i32 = 5;
    const b: i32 = 10;
    const stdout = std.io.getStdOut().writer();

    try stdout.print("等于: {}\n", .{a == b}); // false
    try stdout.print("不等于: {}\n", .{a != b}); // true
    try stdout.print("小于: {}\n", .{a < b});  // true
    try stdout.print("大于等于: {}\n", .{a >= b}); // false
}

说明：

  • 比较运算符适用于整数、浮点数和指针。
  • 类型必须匹配，否则编译错误。

4. 逻辑运算符

用于布尔运算或条件组合。

运算符列表

  • and：逻辑与
  • or：逻辑或
  • !：逻辑非

示例

const std = @import("std");

pub fn main() !void {
    const x: bool = true;
    const y: bool = false;
    const stdout = std.io.getStdOut().writer();

    try stdout.print("与: {}\n", .{x and y}); // false
    try stdout.print("或: {}\n", .{x or y});  // true
    try stdout.print("非: {}\n", .{!y});      // true
}

说明：

  • 逻辑运算符仅适用于 bool 类型。
  • and 和 or 具有短路求值：
  if (false and expensive_function()) {} // expensive_function 不会执行

5. 位运算符

用于按位操作，适用于整数类型。

运算符列表

  • &：按位与
  • |：按位或
  • ^：按位异或
  • ~：按位取反
  • <<：左移
  • >>：右移

示例

const std = @import("std");

pub fn main() !void {
    const a: u8 = 0b1010; // 10
    const b: u8 = 0b1100; // 12
    const stdout = std.io.getStdOut().writer();

    try stdout.print("与: {b}\n", .{a & b});  // 0b1000 (8)
    try stdout.print("或: {b}\n", .{a | b});  // 0b1110 (14)
    try stdout.print("异或: {b}\n", .{a ^ b}); // 0b0110 (6)
    try stdout.print("取反: {b}\n", .{~a});   // 0b0101 (245)
    try stdout.print("左移: {b}\n", .{a << 1}); // 0b10100 (20)
    try stdout.print("右移: {b}\n", .{a >> 1}); // 0b0101 (5)
}

说明：

  • 位运算符高效，适合低级操作（如嵌入式系统）。
  • 移位操作不会改变符号位（有符号整数需注意）。

6. 赋值运算符

用于更新变量值，支持复合赋值。

运算符列表

  • =：赋值
  • +=, -=, *=, /=, %=：复合赋值
  • &=, |=, ^=, <<=, >>=：位操作赋值
  • +%=, -%=, *%=：溢出环绕赋值

示例

const std = @import("std");

pub fn main() !void {
    var x: i32 = 10;
    const stdout = std.io.getStdOut().writer();

    x += 5; // x = 15
    x *= 2; // x = 30
    x &= 0x1F; // x = 30 & 31 = 30
    try stdout.print("结果: {}\n", .{x});
}

7. 特殊运算符

Zig 提供独特运算符，增强安全性和功能。

7.1 可选类型运算符

  • ?：定义可选类型（可能为 null）。
  • orelse：提供默认值。
  • if 捕获：处理非空值。

示例：

var maybe_num: ?i32 = 42;
const value = maybe_num orelse 0; // 若为空，使用 0

7.2 错误处理运算符

  • !：定义错误联合（可能返回错误）。
  • try：尝试执行可能出错的函数。
  • catch：捕获错误。

示例：

const MyError = error{Invalid};
fn risky() MyError!i32 {
    return MyError.Invalid;
}

const result = risky() catch |err| {
    try std.io.getStdOut().writer().print("错误: {}\n", .{err});
    return;
};

7.3 指针运算符

  • *：解引用指针。
  • &：取地址。
  • .*：访问指针指向的值。

示例：

var x: i32 = 10;
var ptr: *i32 = &x;
ptr.* += 1; // x = 11

7.4 内置函数（@）

Zig 使用 @ 前缀调用内置函数，部分与运算符相关：

  • @intCast：类型转换。
  • @divFloor：整数除法（向下取整）。
  • @sqrt：平方根。

示例：

const x: f32 = 16.0;
const y: i32 = @intCast(42.0);
const z = @sqrt(x); // 4.0

8. 注意事项

  • 类型安全：
  • 运算符要求操作数类型一致：
    zig const a: i32 = 10; const b: u32 = 20; // a + b; // 错误：类型不匹配 const c = a + @intCast(b); // 正确
  • 溢出检查：
  • 默认检查整数溢出，失败时抛出运行时错误。
  • 使用 +% 等运算符禁用检查。
  • 性能：
  • 运算符直接映射到机器指令，效率高。
  • 使用 comptime 优化常量运算：
    zig const sum = comptime 10 + 20; // 编译时计算
  • 调试：
  • 使用 std.debug.print 检查运算结果。
  • 编译时错误提示明确，检查类型或溢出问题。
  • 与 C 互操作：
  • 运算符行为与 C 类似，兼容 C 库调用。

9. 综合示例

以下示例结合多种运算符处理数据：

const std = @import("std");
const MyError = error{Overflow};

fn safe_add(a: u8, b: u8) MyError!u8 {
    if (@addWithOverflow(a, b)[1] != 0) return MyError.Overflow;
    return a + b;
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    var x: u8 = 100;
    const y: u8 = 150;

    // 算术和溢出处理
    const result = safe_add(x, y) catch |err| {
        try stdout.print("加法错误: {}\n", .{err});
        return;
    };
    try stdout.print("加法: {}\n", .{result});

    // 比较和逻辑
    const is_valid = (x > 50) and (y <= 200);
    try stdout.print("有效: {}\n", .{is_valid});

    // 位运算
    const mask = x & 0xF; // 取低 4 位
    try stdout.print("掩码: {b}\n", .{mask});

    // 可选类型
    var maybe_num: ?i32 = 42;
    const value = maybe_num orelse 0;
    try stdout.print("可选值: {}\n", .{value});
}

运行：

zig run example.zig

输出：

加法错误: Overflow

说明：

  • safe_add 使用 @addWithOverflow 检查溢出。
  • 结合比较、逻辑和位运算符。
  • 可选类型通过 orelse 提供默认值。

10. 总结

Zig 的运算符系统简洁高效：

  • 算术：+, -, *, /, %，支持溢出检查。
  • 比较：==, !=, <, >, <=, >=，类型严格。
  • 逻辑：and, or, !，短路求值。
  • 位运算：&, |, ^, ~, <<, >>，适合低级操作。
  • 赋值：+=, &=, +%= 等，简化代码。
  • 特殊运算符：支持可选类型（?）、错误处理（try, catch）、指针（*, &）。

Zig 的运算符设计避免了复杂性，通过编译时检查和显式行为提高安全性和性能。推荐通过 Ziglings（https://ziglings.org/）练习运算符使用。

如果你需要更复杂的运算符示例（如位操作优化、错误处理）或有其他问题，请告诉我！

类似文章

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注