1. 复合数据类型

结构体与方法的对比

C++类：

class Vector3 {
public:
    float x, y, z;
    
    Vector3(float x, float y, float z) : x(x), y(y), z(z) {}
    
    float length() const {
        return std::sqrt(x*x + y*y + z*z);
    }
};

Vector3 v(1.0f, 2.0f, 3.0f);
std::cout << v.length() << std::endl;

Zig结构体：

const Vector3 = struct {
    x: f32,
    y: f32,
    z: f32,

    pub fn init(x: f32, y: f32, z: f32) Vector3 {
        return Vector3 { .x = x, .y = y, .z = z };
    }

    pub fn length(self: Vector3) f32 {
        return @sqrt(self.x*self.x + self.y*self.y + self.z*self.z);
    }
};

const v = Vector3.init(1.0, 2.0, 3.0);
std.debug.print("{d}\n", .{v.length()});

关键差异：

• Zig结构体没有继承
• 方法只是结构体内部的普通函数
• 构造器是约定而非语言特性
• self参数是显式的

枚举类型对比

C++枚举：

enum class Color { Red, Green, Blue };

Color c = Color::Red;
switch (c) {
    case Color::Red: /* ... */ break;
    // ...
}

Zig枚举：

const Color = enum { Red, Green, Blue };

const c = Color.Red;
switch (c) {
    .Red => { /* ... */ },
    // ...
}

Zig特点：

• 更简洁的语法（不需要enum class）
• 枚举值用.前缀访问
• 可以与联合体组合使用

联合体与标记联合

C++联合体：

union Data {
    int i;
    float f;
    char str[20];
};

Data d;
d.i = 10;

Zig标记联合：

const Data = union(enum) {
    Int: i32,
    Float: f32,
    String: [20]u8,
};

var d = Data{ .Int = 10 };
switch (d) {
    .Int => |val| std.debug.print("int: {d}\n", .{val}),
    // ...
}

Zig优势：

• 类型安全的联合体
• 通过union(enum)实现标记联合
• 模式匹配支持

2. 泛型与元编程

编译时泛型对比

C++模板：

template<typename T>
T max(T a, T b) {
    return a > b ? a : b;
}

auto m = max(1, 2);  // 类型推导

Zig编译时泛型：

fn max(comptime T: type, a: T, b: T) T {
    return if (a > b) a else b;
}

const m = max(i32, 1, 2);
// 或使用类型推导
const m = max(@TypeOf(1, 2), 1, 2);

关键差异：

• Zig使用comptime参数实现泛型
• 类型作为一等公民传递
• 编译时类型检查更严格

编译时反射

C++ (使用模板元编程)：

template<typename T>
void printType() {
    std::cout << typeid(T).name() << std::endl;
}

Zig:

fn printType(comptime T: type) void {
    std.debug.print("{s}\n", .{@typeName(T)});
}

Zig优势：

• 内置反射能力
• 编译时类型信息更丰富
• 可与普通代码混合使用

3. 并发编程

线程创建对比

C++:

#include <thread>

void task() {
    std::cout << "Hello from thread" << std::endl;
}

int main() {
    std::thread t(task);
    t.join();
    return 0;
}

Zig:

const std = @import("std");

fn task() void {
    std.debug.print("Hello from thread\n", .{});
}

pub fn main() !void {
    var thread = try std.Thread.spawn(.{}, task);
    thread.join();
}

异步/协程对比

C++20协程：

#include <coroutine>
#include <iostream>

Generator<int> range(int start, int end) {
    for (int i = start; i < end; ++i)
        co_yield i;
}

int main() {
    for (int i : range(1, 5)) {
        std::cout << i << std::endl;
    }
}

Zig异步：

const std = @import("std");

fn range(start: i32, end: i32) async std.mem.Allocator {
    var i = start;
    while (i < end) : (i += 1) {
        suspend {
            return i;
        }
    }
}

pub fn main() !void {
    var frame = async range(1, 5);
    while (resume frame) |value| {
        std.debug.print("{d}\n", .{value});
    }
}

Zig特点：

• 更简单的协程实现
• 显式控制协程生命周期
• 与错误处理无缝集成

4. 与C/C++互操作

调用C函数

C头文件 (math.h):

double sqrt(double x);

Zig调用：

const c = @cImport({
    @cInclude("math.h");
});

pub fn main() void {
    const x = c.sqrt(2.0);
    std.debug.print("{d}\n", .{x});
}

导出Zig函数给C

Zig代码：

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

C调用：

// 自动生成的头文件内容相当于：
// int add(int a, int b);

#include <stdio.h>

int add(int a, int b);

int main() {
    printf("%d\n", add(2, 3));
    return 0;
}

混合项目构建

Zig构建脚本 (build.zig):

const std = @import("std");

pub fn build(b: *std.Build) void {
    const exe = b.addExecutable(.{
        .name = "mixed_app",
        .root_source_file = .{ .path = "src/main.zig" },
        .target = b.host,
    });

    // 链接C文件
    exe.addCSourceFile(.{ .file = .{ .path = "src/helper.c" }, .flags = &[_][]const u8{} });
    exe.linkLibC();

    b.installArtifact(exe);
}

C++类包装示例

C++类：

// counter.h
class Counter {
public:
    Counter(int start);
    void increment();
    int get() const;
private:
    int value;
};

Zig包装：

const cpp_counter = @cImport({
    @cInclude("counter.h");
});

const Counter = struct {
    ptr: *cpp_counter.Counter,

    pub fn init(start: i32) Counter {
        return .{ .ptr = cpp_counter.Counter.new(start) };
    }

    pub fn deinit(self: Counter) void {
        cpp_counter.Counter.delete(self.ptr);
    }

    pub fn increment(self: Counter) void {
        self.ptr.increment();
    }

    pub fn get(self: Counter) i32 {
        return self.ptr.get();
    }
};

总结

中篇探讨了Zig的中级概念和与C/C++的互操作：

1. 复合数据类型：Zig的结构体、枚举和联合体设计更简单但表达能力不弱
2. 泛型与元编程：通过comptime实现编译时泛型和反射
3. 并发编程：更轻量级的线程和协程模型
4. 互操作性：与C的无缝互操作，C++需要通过C接口包装

下篇将深入高级主题，包括SIMD优化、裸函数、性能调优和实际项目迁移策略。