docs(course): 添加 Zig 0.16 完整课程代码示例

- 更新构建配置至 0.16 版本
- 添加数组、原子、字符、布尔等基础语言特性示例
- 添加编译期计算、反射、错误处理等高级特性示例
- 添加完整的构建系统示例集（基础、CLI、库、文档等）
- 添加包管理和依赖导入示例
- 添加内存管理、网络编程等实战示例

Author: jinzhongjia

build/0.16.zig

@@ -2,12 +2,11 @@ const std = @import("std");
 const Build = std.Build;
 const ChildProcess = std.process.Child;
 
-const log = std.log.scoped(.For_0_15_0);
+const log = std.log.scoped(.For_0_16_0);
+const version = "16";
 
 const args = [_][]const u8{ "zig", "build" };
 
-const version = "15";
-
 const relative_path = "course/code/" ++ version;
 
 pub fn build(b: *Build) void {

course/code/16/array.zig

@@ -0,0 +1,136 @@
+pub fn main() !void {
+    CreateArray.main();
+    Deconstruct.main();
+    Matrix.main();
+    TerminatedArray.main();
+    Multiply.main();
+    Connect.main();
+    FuncInitArray.main();
+    ComptimeInitArray.main();
+}
+const CreateArray = struct {
+    // #region create_array
+    const print = @import("std").debug.print;
+
+    pub fn main() void {
+        const message = [5]u8{ 'h', 'e', 'l', 'l', 'o' };
+        // const message = [_]u8{ 'h', 'e', 'l', 'l', 'o' };
+        print("{s}\n", .{message}); // hello
+        print("{c}\n", .{message[0]}); // h
+    }
+    // #endregion create_array
+};
+
+const Deconstruct = struct {
+    // #region deconstruct
+    const print = @import("std").debug.print;
+
+    fn swizzleRgbaToBgra(rgba: [4]u8) [4]u8 {
+        // 解构
+        const r, const g, const b, const a = rgba;
+        return .{ b, g, r, a };
+    }
+
+    pub fn main() void {
+        const pos = [_]i32{ 1, 2 };
+        // 解构
+        const x, const y = pos;
+        print("x = {}, y = {}\n", .{ x, y });
+
+        const orange: [4]u8 = .{ 255, 165, 0, 255 };
+        print("{any}\n", .{swizzleRgbaToBgra(orange)});
+    }
+    // #endregion deconstruct
+};
+
+const Matrix = struct {
+    // #region matrix
+    const print = @import("std").debug.print;
+
+    pub fn main() void {
+        const matrix_4x4 = [4][4]f32{
+            [_]f32{ 1.0, 0.0, 0.0, 0.0 },
+            [_]f32{ 0.0, 1.0, 0.0, 1.0 },
+            [_]f32{ 0.0, 0.0, 1.0, 0.0 },
+            [_]f32{ 0.0, 0.0, 0.0, 1.0 },
+        };
+
+        for (matrix_4x4, 0..) |arr_val, arr_index| {
+            for (arr_val, 0..) |val, index| {
+                print("元素{}-{}是: {}\n", .{ arr_index, index, val });
+            }
+        }
+    }
+    // #endregion matrix
+};
+
+const TerminatedArray = struct {
+    // #region terminated_array
+    const print = @import("std").debug.print;
+
+    pub fn main() void {
+        const array = [_:0]u8{ 1, 2, 3, 4 };
+        print("数组长度为: {}\n", .{array.len}); // 4
+        print("数组最后一个元素值: {}\n", .{array[array.len - 1]}); // 4
+        print("哨兵值为: {}\n", .{array[array.len]}); // 0
+    }
+    // #endregion terminated_array
+};
+
+const Multiply = struct {
+    // #region multiply
+    const print = @import("std").debug.print;
+
+    pub fn main() void {
+        const small = [3]i8{ 1, 2, 3 };
+        const big: [9]i8 = small ** 3;
+        print("{any}\n", .{big}); // [9]i8{ 1, 2, 3, 1, 2, 3, 1, 2, 3 }
+    }
+    // #endregion multiply
+};
+
+const Connect = struct {
+    // #region connect
+    const print = @import("std").debug.print;
+
+    pub fn main() void {
+        const part_one = [_]i32{ 1, 2, 3, 4 };
+        const part_two = [_]i32{ 5, 6, 7, 8 };
+        const all_of_it = part_one ++ part_two; // [_]i32{ 1, 2, 3, 4, 5, 6, 7, 8 }
+
+        _ = all_of_it;
+    }
+    // #endregion connect
+};
+
+const FuncInitArray = struct {
+    // #region func_init_array
+    const print = @import("std").debug.print;
+
+    pub fn main() void {
+        const array = [_]i32{make(3)} ** 10;
+        print("{any}\n", .{array});
+    }
+
+    fn make(x: i32) i32 {
+        return x + 1;
+    }
+    // #endregion func_init_array
+};
+
+const ComptimeInitArray = struct {
+    // #region comptime_init_array
+    const print = @import("std").debug.print;
+
+    pub fn main() void {
+        const fancy_array = init: {
+            var initial_value: [10]usize = undefined;
+            for (&initial_value, 0..) |*pt, i| {
+                pt.* = i;
+            }
+            break :init initial_value;
+        };
+        print("{any}\n", .{fancy_array});
+    }
+    // #endregion comptime_init_array
+};

course/code/16/assembly.zig

@@ -0,0 +1,69 @@
+pub fn main() !void {}
+
+const external_assembly = struct {
+    // #region external_assembly
+    const std = @import("std");
+
+    comptime {
+        asm (
+            \\.global my_func;
+            \\.type my_func, @function;
+            \\my_func:
+            \\  lea (%rdi,%rsi,1),%eax
+            \\  retq
+        );
+    }
+
+    extern fn my_func(a: i32, b: i32) i32;
+
+    pub fn main() void {
+        std.debug.print("{}\n", .{my_func(2, 5)});
+    }
+    // #endregion external_assembly
+};
+
+const inline_assembly = struct {
+    // #region inline_assembly
+    const std = @import("std");
+
+    pub fn main() noreturn {
+        // Temporarily disabled due to Zig 0.15 syntax changes
+        // const msg = "hello world\n";
+        // _ = syscall3(SYS_write, STDOUT_FILENO, @intFromPtr(msg), msg.len);
+        // _ = syscall1(SYS_exit, 0);
+        std.process.exit(0);
+    }
+
+    pub const SYS_write = 1;
+    pub const SYS_exit = 60;
+
+    pub const STDOUT_FILENO = 1;
+
+    // Temporarily disabled due to Zig 0.15 inline assembly syntax changes
+    // TODO: Update to new Zig 0.15 inline assembly syntax
+
+    // pub fn syscall1(number: usize, arg1: usize) usize {
+    //     var result: usize = undefined;
+    //     asm volatile ("syscall"
+    //         : [ret] "={rax}" (result)
+    //         : [number] "{rax}" (number),
+    //           [arg1] "{rdi}" (arg1)
+    //         : "rcx", "r11"
+    //     );
+    //     return result;
+    // }
+
+    // pub fn syscall3(number: usize, arg1: usize, arg2: usize, arg3: usize) usize {
+    //     var result: usize = undefined;
+    //     asm volatile ("syscall"
+    //         : [ret] "={rax}" (result)
+    //         : [number] "{rax}" (number),
+    //           [arg1] "{rdi}" (arg1),
+    //           [arg2] "{rsi}" (arg2),
+    //           [arg3] "{rdx}" (arg3)
+    //         : "rcx", "r11"
+    //     );
+    //     return result;
+    // }
+    // #endregion inline_assembly
+};

course/code/16/atomic.zig

@@ -0,0 +1,50 @@
+pub fn main() !void {
+    // #region atomic_value
+    const std = @import("std");
+    const RefCount = struct {
+        count: std.atomic.Value(usize),
+        dropFn: *const fn (*RefCount) void,
+
+        const RefCount = @This();
+
+        fn ref(rc: *RefCount) void {
+            // no synchronization necessary; just updating a counter.
+            _ = rc.count.fetchAdd(1, .monotonic);
+        }
+
+        fn unref(rc: *RefCount) void {
+            // release ensures code before unref() happens-before the
+            // count is decremented as dropFn could be called by then.
+            if (rc.count.fetchSub(1, .release) == 1) {
+                // seeing 1 in the counter means that other unref()s have happened,
+                // but it doesn't mean that uses before each unref() are visible.
+                // The load acquires the release-sequence created by previous unref()s
+                // in order to ensure visibility of uses before dropping.
+                _ = rc.count.load(.acquire);
+                (rc.dropFn)(rc);
+            }
+        }
+
+        fn noop(rc: *RefCount) void {
+            _ = rc;
+        }
+    };
+
+    var ref_count: RefCount = .{
+        .count = std.atomic.Value(usize).init(0),
+        .dropFn = RefCount.noop,
+    };
+    ref_count.ref();
+    ref_count.unref();
+    // #endregion atomic_value
+
+}
+
+test "spinLoopHint" {
+    const std = @import("std");
+    // #region spinLoopHint
+    for (0..10) |_| {
+        std.atomic.spinLoopHint();
+    }
+    // #endregion spinLoopHint
+}

course/code/16/build_system/README.md

@@ -0,0 +1 @@
+该文件夹是构建系统的示例文件！

course/code/16/build_system/basic/build.zig

@@ -0,0 +1,17 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const exe = b.addExecutable(.{
+        .name = "zig",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
+    });
+
+    b.installArtifact(exe);
+}

course/code/16/build_system/basic/build.zig.zon

@@ -0,0 +1,73 @@
+.{
+    // This is the default name used by packages depending on this one. For
+    // example, when a user runs `zig fetch --save <url>`, this field is used
+    // as the key in the `dependencies` table. Although the user can choose a
+    // different name, most users will stick with this provided value.
+    //
+    // It is redundant to include "zig" in this name because it is already
+    // within the Zig package namespace.
+    .name = .basic,
+
+    // This is a [Semantic Version](https://semver.org/).
+    // In a future version of Zig it will be used for package deduplication.
+    .version = "0.0.0",
+    .fingerprint = 0x907975534fe79435,
+
+    // This field is optional.
+    // This is currently advisory only; Zig does not yet do anything
+    // with this value.
+    //.minimum_zig_version = "0.11.0",
+
+    // This field is optional.
+    // Each dependency must either provide a `url` and `hash`, or a `path`.
+    // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
+    // Once all dependencies are fetched, `zig build` no longer requires
+    // internet connectivity.
+    .dependencies = .{
+        // See `zig fetch --save <url>` for a command-line interface for adding dependencies.
+        //.example = .{
+        //    // When updating this field to a new URL, be sure to delete the corresponding
+        //    // `hash`, otherwise you are communicating that you expect to find the old hash at
+        //    // the new URL.
+        //    .url = "https://example.com/foo.tar.gz",
+        //
+        //    // This is computed from the file contents of the directory of files that is
+        //    // obtained after fetching `url` and applying the inclusion rules given by
+        //    // `paths`.
+        //    //
+        //    // This field is the source of truth; packages do not come from a `url`; they
+        //    // come from a `hash`. `url` is just one of many possible mirrors for how to
+        //    // obtain a package matching this `hash`.
+        //    //
+        //    // Uses the [multihash](https://multiformats.io/multihash/) format.
+        //    .hash = "...",
+        //
+        //    // When this is provided, the package is found in a directory relative to the
+        //    // build root. In this case the package's hash is irrelevant and therefore not
+        //    // computed. This field and `url` are mutually exclusive.
+        //    .path = "foo",
+
+        //    // When this is set to `true`, a package is declared to be lazily
+        //    // fetched. This makes the dependency only get fetched if it is
+        //    // actually used.
+        //    .lazy = false,
+        //},
+    },
+
+    // Specifies the set of files and directories that are included in this package.
+    // Only files and directories listed here are included in the `hash` that
+    // is computed for this package. Only files listed here will remain on disk
+    // when using the zig package manager. As a rule of thumb, one should list
+    // files required for compilation plus any license(s).
+    // Paths are relative to the build root. Use the empty string (`""`) to refer to
+    // the build root itself.
+    // A directory listed here means that all files within, recursively, are included.
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        // For example...
+        //"LICENSE",
+        //"README.md",
+    },
+}

course/code/16/build_system/basic/src/main.zig

@@ -0,0 +1,24 @@
+const std = @import("std");
+
+pub fn main() !void {
+    // Prints to stderr (it's a shortcut based on `std.io.getStdErr()`)
+    std.debug.print("All your {s} are belong to us.\n", .{"codebase"});
+
+    // stdout is for the actual output of your application, for example if you
+    // are implementing gzip, then only the compressed bytes should be sent to
+    // stdout, not any debugging messages.
+    var stdout_buffer: [1024]u8 = undefined;
+    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    const stdout = &stdout_writer.interface;
+
+    try stdout.print("Run `zig build test` to run the tests.\n", .{});
+
+    try stdout.flush();
+}
+
+test "simple test" {
+    var list = std.ArrayList(i32).init(std.testing.allocator);
+    defer list.deinit(); // try commenting this out and see if zig detects the memory leak!
+    try list.append(42);
+    try std.testing.expectEqual(@as(i32, 42), list.pop());
+}