Zig 语言入门：比 C 更安全的系统编程

如果你写 C 写了十年，厌倦了空指针崩溃、隐式转换陷阱和手动内存管理的刀尖跳舞；如果你觉得 Rust 的借用检查器和生命周期标注太过繁重，学习曲线陡峭到让人望而却步——那么 Zig 可能是你一直在找的那个平衡点。

Zig 是一门现代化的系统编程语言，目标是成为「更好的 C」。它没有运行时、没有隐式控制流、没有垃圾回收，却通过编译期计算、显式内存分配和类型安全的错误处理，提供了远超 C 的安全保障——同时保持与 C 的完美互操作性。

一、Zig 的定位：什么问题在解决

Zig 的作者 Andrew Kelley 在设计这门语言时，有一个明确的信条：最可读的代码是没有的代码。Zig 的每一个设计决策都围绕一个核心目标——让程序员对程序的行为拥有完全的控制权，同时消除 C 中最常见的陷阱。

四大核心原则

用一句话概括 Zig 的哲学：如果你没写，它就不会发生。

// C：隐式类型转换，你以为没问题，实际上溢出了
int x = -1;
unsigned int y = x;  // y 变成 4294967295，没有警告

// Zig：显式转换，必须写清楚
var x: i32 = -1;
var y: u32 = @intCast(x);  // 运行时溢出会 panic，安全！

二、基础语法速览

变量声明

const std = @import("std");

pub fn main() void {
    // const 不可变，var 可变
    const pi: f64 = 3.14159;
    var count: u32 = 0;
    count += 1;

    // 类型推导
    const name = "Zig";      // *const [3:0]u8
    const version = 0.14;    // comptime_float

    // 未使用变量会编译报错，用 _ 忽略
    const _unused = 42;
}

函数

// 基本函数
fn add(a: i32, b: i32) i32 {
    return a + b;
}

// 错误联合类型
fn divide(a: f64, b: f64) !f64 {
    if (b == 0) return error.DivisionByZero;
    return a / b;
}

// defer 确保清理
fn readFile(path: []const u8) ![]u8 {
    const file = try std.fs.cwd().openFile(path, .{});
    defer file.close();  // 函数退出时必定执行
    const stat = try file.stat();
    const buf = try allocator.alloc(u8, stat.size);
    _ = try file.readAll(buf);
    return buf;
}

控制流

// if 是表达式
const max = if (a > b) a else b;

// switch 也是表达式，必须穷尽所有分支
const tag = switch (node) {
    .add => "ADD",
    .sub => "SUB",
    .mul => "MUL",
};

// for 遍历（Zig 没有 C 风格的 for(i=0; i<n; i++)）
const items = [_]i32{ 1, 2, 3, 4, 5 };
for (items, 0..) |item, index| {
    std.debug.print("[{}] = {}\n", .{ index, item });
}

// while 带 continue 表达式
var i: usize = 0;
while (i < 10) : (i += 1) {
    if (i == 3) continue;
    std.debug.print("{} ", .{i});
}

comptime：编译期计算

comptime 是 Zig 最强大的特性之一——它让你在编译期执行任意 Zig 代码，而运行时零开销。

// 编译期常量
const factorial = comptime {
    var result: u64 = 1;
    var i: u64 = 1;
    while (i <= 20) : (i += 1) {
        result *= i;
    }
    break :result result;
};
// factorial 在编译期就已计算完毕，运行时就是一个常量

// 编译期泛型：类型作为参数
fn Vector(comptime T: type, comptime len: usize) type {
    return [len]T;
}

const Vec3f = Vector(f32, 3);  // 等价于 [3]f32
const Vec4i = Vector(i32, 4);  // 等价于 [4]i32

// 编译期条件编译
fn log(msg: []const u8) void {
    if (std.debug.runtime_safety) {
        std.debug.print("{s}\n", .{msg});
    }
    // Release 模式下这段代码根本不存在
}

三、内存管理哲学

Zig 的内存管理哲学可以总结为一句话：没有隐式分配，分配策略由调用者决定。每个需要分配内存的函数都接收一个 Allocator 参数，而不是自己在内部调用 malloc。

Allocator 模式

const allocator = std.heap.page_allocator;  // 最基础的分配器

// 所有分配都显式传入 allocator
const buf = try allocator.alloc(u8, 1024);
defer allocator.free(buf);

const item = try allocator.create(MyStruct);
defer allocator.destroy(item);

三种常用分配器

ArenaAllocator 实战

fn processRequest(allocator: std.mem.Allocator, req: Request) !Response {
    // Arena 分配器：所有分配在 defer 时一次性释放
    var arena = std.heap.ArenaAllocator.init(allocator);
    defer arena.deinit();
    const aa = arena.allocator();

    // 中间分配不需要单独 free，arena.deinit() 统一释放
    const headers = try aa.alloc(Header, req.header_count);
    const body = try aa.alloc(u8, req.body_len);
    const temp = try aa.alloc(u8, 4096);

    // 处理逻辑...
    _ = headers;
    _ = body;
    _ = temp;

    return Response{ .status = 200 };
}

FixedBufferAllocator：零堆分配

// 嵌入式场景：不用堆，用栈上的缓冲区
var buf: [4096]u8 = undefined;
var fba = std.heap.FixedBufferAllocator.init(&buf);
const allocator = fba.allocator();

// 所有分配都从 buf 中切，用完即止
const data = try allocator.alloc(u8, 100);
// 不需要 free，buf 的生命周期由函数栈管理

四、可选类型与错误处理

Zig 用 ?T 表示可选类型，用 !T 表示可能出错的返回值。两者都是显式的，编译器强制你处理。

?T：可选类型

// ?T 表示 T 或 null
const maybe_int: ?i32 = null;
const definitely_int: ?i32 = 42;

// 必须解包才能使用
if (maybe_int) |value| {
    std.debug.print("值为: {}\n", .{value});
} else {
    std.debug.print("无值\n", .{});
}

// orelse 提供默认值
const value = maybe_int orelse 0;

// 可选指针：?*T 比 C 的 NULL 指针更安全
fn findNode(head: ?*Node, target: i32) ?*Node {
    var current = head;
    while (current) |node| : (current = node.next) {
        if (node.data == target) return node;
    }
    return null;
}

!T：错误联合类型

// 定义错误集
const ParseError = error{
    InvalidFormat,
    Overflow,
    EmptyInput,
};

// 返回类型可以是 ParseError!i32（i32 或 ParseError 中的某个错误）
fn parsePositiveInt(str: []const u8) ParseError!u32 {
    if (str.len == 0) return error.EmptyInput;
    var result: u64 = 0;
    for (str) |ch| {
        if (ch < '0' or ch > '9') return error.InvalidFormat;
        result = result * 10 + (ch - '0');
        if (result > std.math.maxInt(u32)) return error.Overflow;
    }
    return @intCast(result);
}

// 调用方必须处理错误
const num = parsePositiveInt("123") catch |err| {
    std.debug.print("解析失败: {}\n", .{err});
    return;
};
std.debug.print("结果: {}\n", .{num});

try 和 catch

// try：错误自动向上传播（类似 ? 操作符）
fn readConfig(path: []const u8) !Config {
    const file = try std.fs.cwd().openFile(path, .{});
    defer file.close();
    const content = try file.readToEndAlloc(allocator, 1024 * 1024);
    return try parseConfig(content);
}

// catch：捕获并处理
const result = parsePositiveInt(input) catch |err| switch (err) {
    error.InvalidFormat => return error.BadInput,
    error.Overflow => return std.math.maxInt(u32),
    error.EmptyInput => return 0,
};

errdefer：错误时的清理

errdefer 只在函数通过错误返回时执行，成功时不执行。这是 Zig 独有的特性，C 和 Rust 都没有直接等价物。

fn createConnection(config: Config) !*Connection {
    const conn = try allocator.create(Connection);
    errdefer allocator.destroy(conn);  // 出错才销毁

    conn.socket = try openSocket(config.addr);
    errdefer closeSocket(conn.socket);  // 出错才关闭

    conn.buffer = try allocator.alloc(u8, config.buf_size);
    errdefer allocator.free(conn.buffer);  // 出错才释放

    conn.state = .connected;
    return conn;  // 成功，三个 errdefer 都不执行
}

五、与 C 互操作

Zig 的 C 互操作能力是同类语言中最强的——不需要 FFI 绑定层，不需要手写 wrapper，直接导入 C 头文件就能用。

@cImport：直接导入 C 头文件

// 直接在 Zig 中使用 C 库
const c = @cImport({
    @cInclude("stdio.h");
    @cInclude("stdlib.h");
});

pub fn main() void {
    // 调用 printf
    _ = c.printf("Hello from C: %d\n".ptr, 42);

    // 调用 malloc/free
    const ptr = c.malloc(1024);
    defer c.free(ptr);
}

翻译 C 头文件

zig translate-c 可以将 C 头文件翻译成 Zig 代码，方便查看类型映射和调试：

$ zig translate-c -lc sqlite3.h > sqlite3.zig

// 生成的 sqlite3.zig 中可以直接看到类型映射
// pub const sqlite3 = opaque {};
// pub extern fn sqlite3_open(filename: [*c]const u8, ppDb: [*c]?*sqlite3) c_int;

在 C 项目中嵌入 Zig

// math_utils.zig
export fn add(a: i32, b: i32) i32 {
    return a + b;
}

export fn mul(a: i32, b: i32) i32 {
    return a * b;
}

// 编译为 .o，C 项目直接链接
// $ zig build-obj math_utils.zig -OReleaseFast
// C 侧：extern int add(int a, int b);

Linker 模式

// build.zig 中控制链接
const exe = b.addExecutable(.{
    .name = "myapp",
    .root_source_file = b.path("src/main.zig"),
    .target = target,
    .optimize = optimize,
});

// 链接 C 库
exe.linkSystemLibrary("sqlite3");
exe.linkLibC();

// 链接静态库
exe.addObjectFile(b.path("vendor/libfoo.a"));

// 添加 C 源文件
exe.addCSourceFile(.{
    .file = b.path("vendor/legacy.c"),
    .flags = &.{"-Wall", "-O2"},
});

六、交叉编译

Zig 内置了交叉编译支持，不需要安装任何交叉编译工具链。一条命令就能为任意目标平台编译。

Target 三元组

// 格式：arch-os-abi
// 常用 target：
// x86_64-linux-gnu      Linux x64 (glibc)
// x86_64-linux-musl     Linux x64 (musl，静态链接)
// aarch64-linux-gnu     Linux ARM64
// x86_64-windows-gnu    Windows x64 (MinGW)
// x86_64-macos          macOS x64
// aarch64-macos         macOS Apple Silicon
// wasm32-freestanding   WebAssembly

// 查看所有支持的目标
$ zig targets

// 直接交叉编译
$ zig build-exe src/main.zig -target aarch64-linux-gnu
$ zig build-exe src/main.zig -target x86_64-windows-gnu
$ zig build-exe src/main.zig -target wasm32-freestanding

sysroot 配置

// 交叉编译时指定 sysroot（目标系统的头文件和库）
$ zig build-exe src/main.zig \
    -target aarch64-linux-gnu \
    --sysroot /path/to/sysroot \
    -L /path/to/sysroot/usr/lib

// build.zig 中配置
const exe = b.addExecutable(.{
    .name = "myapp",
    .root_source_file = b.path("src/main.zig"),
    .target = b.resolveTargetQuery(.{
        .cpu_arch = .aarch64,
        .os_tag = .linux,
        .abi = .gnu,
    }),
    .optimize = .ReleaseFast,
});

// Zig 自带 glibc 的所有版本，可以精确指定
// 编译时动态选择 glibc 版本
exe.setGlibcVersion(.{ .major = 2, .minor = 31 });

七、构建系统：build.zig

Zig 自带构建系统，用 build.zig 文件描述构建规则，取代 Makefile、CMake 等外部工具。

基本 build.zig

const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    // 可执行文件
    const exe = b.addExecutable(.{
        .name = "myapp",
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
    });

    // 安装到 zig-out/bin/
    b.installArtifact(exe);

    // 运行命令：zig build run
    const run_cmd = b.addRunArtifact(exe);
    run_cmd.step.dependOn(b.getInstallStep());
    const run_step = b.step("run", "Run the app");
    run_step.dependOn(&run_cmd.step);

    // 测试命令：zig build test
    const unit_tests = b.addTest(.{
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
    });
    const run_unit_tests = b.addRunArtifact(unit_tests);
    const test_step = b.step("test", "Run unit tests");
    test_step.dependOn(&run_unit_tests.step);
}

依赖管理

// build.zig.zon：项目清单（类似 package.json）
// .{
//     .name = "myapp",
//     .version = "0.1.0",
//     .dependencies = .{
//         // 从 GitHub 获取依赖
//         .zlib = .{
//             .url = "https://github.com/...",
//             .hash = "1220...",
//         },
//     },
// }

// build.zig 中使用依赖
const zlib_dep = b.dependency("zlib", .{
    .target = target,
    .optimize = optimize,
});
exe.root_module.addImport("zlib", zlib_dep.module("zlib"));

// 添加依赖
$ zig fetch --save https://github.com/user/repo/tarball/commit-hash

模块化

// 创建库模块
const lib = b.addStaticLibrary(.{
    .name = "mylib",
    .root_source_file = b.path("src/lib.zig"),
    .target = target,
    .optimize = optimize,
});
b.installArtifact(lib);

// 可执行文件依赖库模块
exe.root_module.addImport("mylib", lib.root_module);

// 源文件中使用
// const mylib = @import("mylib");

八、性能与安全性对比

Zig vs C vs Rust 核心特性对比

性能基准参考

九、实战用例

1. CLI 工具

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    const args = try std.process.argsAlloc(allocator);
    defer std.process.argsFree(allocator, args);

    if (args.len < 2) {
        std.debug.print("用法: {s} <文件路径>\n", .{args[0]});
        return;
    }

    const path = args[1];
    const file = try std.fs.cwd().openFile(path, .{});
    defer file.close();

    const content = try file.readToEndAlloc(allocator, 1024 * 1024);
    defer allocator.free(content);

    const line_count = std.mem.count(u8, content, "\n");
    const word_count = std.mem.count(u8, content, " ") + line_count;
    const byte_count = content.len;

    std.debug.print("  {d} 行  {d} 词  {d} 字节  {s}\n", .{
        line_count, word_count, byte_count, path,
    });
}

2. WebAssembly

// 编译目标：wasm32-freestanding
// $ zig build-lib src/main.zig -target wasm32-freestanding -OReleaseSmall

const std = @import("std");

// 导出给 JS 调用的函数
export fn add(a: i32, b: i32) i32 {
    return a + b;
}

export fn fibonacci(n: i32) i32 {
    if (n <= 1) return n;
    var a: i32 = 0;
    var b: i32 = 1;
    var i: i32 = 1;
    while (i < n) : (i += 1) {
        const tmp = a + b;
        a = b;
        b = tmp;
    }
    return b;
}

// JS 侧调用
// const wasm = await WebAssembly.instantiateStreaming(fetch("main.wasm"));
// console.log(wasm.instance.exports.add(3, 4));       // 7
// console.log(wasm.instance.exports.fibonacci(10));   // 55

3. 嵌入式

// 裸机环境，不依赖 libc
const std = @import("std");
const micro = @import("microzig");

// LED 闪烁（基于 MicroZig 框架）
pub fn main() void {
    const led = micro.Gpio(13, .{ .mode = .output });

    while (true) {
        led.write(.high);
        delay(500_000);
        led.write(.low);
        delay(500_000);
    }
}

fn delay(cycles: u32) void {
    var i: u32 = 0;
    while (i < cycles) : (i += 1) {
        @noInlineCall(std.mem.doNotOptimizeAway, i);
    }
}

// 编译：zig build -Dtarget=avr-atmega328p-freestanding

十、速查表