1. Zig语言概述

Zig是一门新兴的系统编程语言，旨在成为C/C++的现代替代品。与C++相比，Zig的设计更加精简和明确：

• 无隐藏控制流：Zig没有异常、没有隐式内存分配
• 编译时计算：强大的编译期代码执行能力
• 手动内存管理：提供灵活的内存分配策略
• 与C的完美互操作：无需包装即可直接使用C库

2. 开发环境搭建

安装Zig

Zig的安装比C++工具链简单得多：

# Linux/macOS
brew install zig  # 或从官网下载预编译二进制包

# Windows
choco install zig  # 或使用安装程序

第一个程序对比

C版本 (main.c):

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

C++版本 (main.cpp):

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

Zig版本 (main.zig):

const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Hello, World!\n", .{});
}

构建命令对比：

• C: gcc main.c -o hello
• C++: g++ main.cpp -o hello
• Zig: zig build-exe main.zig -O ReleaseSmall

3. 基础语法对比

变量声明

C:

int x = 42;
const char* str = "hello";

C++:

int x = 42;
const auto str = "hello"s;  // std::string

Zig:

var x: i32 = 42;    // 可变变量
const y = 42;       // 不可变常量
const str = "hello"; // 字符串常量

Zig特点：

• 必须显式声明可变性(var/const)
• 类型可以后置（x: i32）
• 字符串是UTF-8编码的字节切片

控制结构

条件语句对比

C/C++:

if (x > 0) {
    printf("positive\n");
} else if (x < 0) {
    printf("negative\n");
} else {
    printf("zero\n");
}

Zig:

if (x > 0) {
    std.debug.print("positive\n", .{});
} else if (x < 0) {
    std.debug.print("negative\n", .{});
} else {
    std.debug.print("zero\n", .{});
}

循环对比

C/C++:

for (int i = 0; i < 10; ++i) {
    printf("%d\n", i);
}

int i = 0;
while (i < 10) {
    printf("%d\n", i++);
}

Zig:

for (0..10) |i| {
    std.debug.print("{d}\n", .{i});
}

var i: u32 = 0;
while (i < 10) : (i += 1) {
    std.debug.print("{d}\n", .{i});
}

Zig特点：

• 区间语法简洁（0..10）
• 循环变量通过管道符|i|捕获
• while循环的步进表达式在循环定义中声明

函数定义

C:

int add(int a, int b) {
    return a + b;
}

C++:

int add(int a, int b) {
    return a + b;
}

// 或者使用模板
template<typename T>
T add(T a, T b) {
    return a + b;
}

Zig:

fn add(a: i32, b: i32) i32 {
    return a + b;
}

// 编译时泛型
fn add(comptime T: type, a: T, b: T) T {
    return a + b;
}

调用对比：

• C/C++: add(1, 2)
• Zig: add(i32, 1, 2) 或特化版本 add(1, 2)

错误处理

C++ (异常):

int parseNumber(const std::string& s) {
    try {
        return std::stoi(s);
    } catch (const std::exception& e) {
        return -1; // 或者重新抛出
    }
}

Zig (错误联合类型):

fn parseNumber(s: []const u8) !i32 {
    return std.fmt.parseInt(i32, s, 10);
}

// 使用示例
pub fn main() !void {
    const num = try parseNumber("42");
    // 或者处理错误
    const num = parseNumber("abc") catch |err| {
        std.debug.print("Error: {}\n", .{err});
        return err;
    };
}

Zig错误处理特点：

• 使用!T表示可能返回错误的类型
• try关键字传播错误
• catch处理错误
• 编译时强制错误处理

4. 内存管理

基本内存操作对比

C:

int* arr = malloc(10 * sizeof(int));
if (arr == NULL) {
    // 处理错误
}
free(arr);

C++:

// 手动管理
int* arr = new int[10];
delete[] arr;

// 或者使用智能指针
auto arr = std::make_unique<int[]>(10);

Zig:

const allocator = std.heap.page_allocator;
var arr = try allocator.alloc(i32, 10);
defer allocator.free(arr);

Zig内存管理特点：

• 显式传递分配器
• defer确保资源释放
• 没有隐式内存分配

结构体对比

C:

struct Point {
    int x;
    int y;
};

struct Point p = { .x = 1, .y = 2 };

C++:

struct Point {
    int x;
    int y;
};

auto p = Point{1, 2};
// 或者带名称初始化
auto p = Point{.x = 1, .y = 2};

Zig:

const Point = struct {
    x: i32,
    y: i32,
};

const p = Point{ .x = 1, .y = 2 };

Zig结构体特点：

• 可以包含函数
• 支持编译时反射
• 没有继承，使用组合代替

总结

上篇介绍了Zig的基础语法和与C/C++的主要差异。关键要点：

1. Zig语法更简洁但更显式
2. 错误处理通过错误联合类型而非异常
3. 内存管理完全手动但更安全
4. 编译时计算能力强大
5. 与C的无缝互操作

中篇将深入探讨Zig的中级概念，包括泛型、并发编程和与C++的互操作技术。