用户自定义类型

const std = @import("std");

// Chapter 8 — Struct basics: fields, methods, defaults, namespacing
//
// Demonstrates defining a struct with fields and methods, including
// default field values. Also shows namespacing of methods vs free functions.
//
// Usage:
//    zig run struct_basics.zig
// 第8章 - 结构体基础：字段、方法、默认值、命名空间
//
// 演示定义具有字段和方法的结构体，包括
// 默认字段值。还将展示方法与自由函数的命名空间区别。
//
// 用法：
//    zig run struct_basics.zig

const Point = struct {
    x: i32,
    y: i32 = 0, // default value
    // 默认值

    pub fn len(self: Point) f64 {
        const dx = @as(f64, @floatFromInt(self.x));
        const dy = @as(f64, @floatFromInt(self.y));
        return std.math.sqrt(dx * dx + dy * dy);
    }

    pub fn translate(self: *Point, dx: i32, dy: i32) void {
        self.x += dx;
        self.y += dy;
    }
};

// Namespacing: free function in file scope vs method
// 命名空间：文件作用域的自由函数与方法
fn distanceFromOrigin(p: Point) f64 {
    return p.len();
}

pub fn main() !void {
    var p = Point{ .x = 3 }; // y uses default 0
    // y使用默认值0
    std.debug.print("p=({d},{d}) len={d:.3}\n", .{ p.x, p.y, p.len() });

    p.translate(-3, 4);
    std.debug.print("p=({d},{d}) len={d:.3}\n", .{ p.x, p.y, distanceFromOrigin(p) });
}

const std = @import("std");

// Chapter 8 — Enums: integer repr, conversions, exhaustiveness
//
// Demonstrates defining an enum with explicit integer representation,
// converting between enum and integer using @intFromEnum and @enumFromInt,
// and pattern matching with exhaustiveness checking.
//
// Usage:
//    zig run enum_roundtrip.zig
// 第8章 - 枚举：整数表示、转换、穷举性检查
//
// 演示定义具有显式整数表示的枚举，
// 使用@intFromEnum和@enumFromInt在枚举和整数之间进行转换，
// 以及具有穷举性检查的模式匹配。
//
// 用法：
//    zig run enum_roundtrip.zig

const Mode = enum(u8) {
    Idle = 0,
    Busy = 1,
    Paused = 2,
};

fn describe(m: Mode) []const u8 {
    return switch (m) {
        .Idle => "idle",
        .Busy => "busy",
        .Paused => "paused",
    };
}

pub fn main() !void {
    const m: Mode = .Busy;
    const int_val: u8 = @intFromEnum(m);
    std.debug.print("m={s} int={d}\n", .{ describe(m), int_val });

    // Round-trip using @enumFromInt; the integer must map to a declared tag.
    // 使用@enumFromInt进行往返转换；整数必须映射到已声明的标签。
    const m2: Mode = @enumFromInt(2);
    std.debug.print("m2={s} int={d}\n", .{ describe(m2), @intFromEnum(m2) });
}

const std = @import("std");

// Chapter 8 — Unions: tagged and untagged
//
// Demonstrates a tagged union (with enum discriminant) and an untagged union
// (without discriminant). Tagged unions are safe and idiomatic; untagged
// unions are advanced and unsafe if used incorrectly.
//
// Usage:
//    zig run union_demo.zig
// 第8章 - 联合体：带标签和无标签
//
// 演示带标签的联合体（带枚举判别式）和无标签联合体
// （不带判别式）。带标签的联合体是安全且惯用的；无标签
// 联合体是高级特性，如果使用不当则不安全。
//
// 用法：
//    zig run union_demo.zig

const Kind = enum { number, text };

const Value = union(Kind) {
    number: i64,
    text: []const u8,
};

// Untagged union (advanced): requires external tracking and is unsafe if used wrong.
    // 无标签联合体（高级）：需要外部跟踪，如果使用不当则不安全。
const Raw = union { u: u32, i: i32 };

pub fn main() !void {
    var v: Value = .{ .number = 42 };
    printValue("start: ", v);

    v = .{ .text = "hi" };
    printValue("update: ", v);

    // Untagged example: write as u32, read as i32 (bit reinterpret).
    // 无标签示例：作为u32写入，作为i32读取（位重新解释）。
    const r = Raw{ .u = 0xFFFF_FFFE }; // -2 as signed 32-bit
    // 作为带符号32位整数的-2
    const as_i: i32 = @bitCast(r.u);
    std.debug.print("raw u=0x{X:0>8} i={d}\n", .{ r.u, as_i });
}

fn printValue(prefix: []const u8, v: Value) void {
    switch (v) {
        .number => |n| std.debug.print("{s}number={d}\n", .{ prefix, n }),
        .text => |s| std.debug.print("{s}{s}\n", .{ prefix, s }),
    }
}

const std = @import("std");

// Chapter 8 — Layout (packed/extern) and anonymous structs/tuples
// 第8章 - 布局（packed/extern）和匿名结构体/元组

const Packed = packed struct {
    a: u3,
    b: u5,
};

const Extern = extern struct {
    a: u32,
    b: u8,
};

pub fn main() !void {
    // Packed bit-fields combine into a single byte.
    // 压缩位域合并为单个字节。
    std.debug.print("packed.size={d}\n", .{@sizeOf(Packed)});

    // Extern layout matches the C ABI (padding may be inserted).
    // Extern布局匹配C ABI（可能会插入填充）。
    std.debug.print("extern.size={d} align={d}\n", .{ @sizeOf(Extern), @alignOf(Extern) });

    // Anonymous struct (tuple) literals and destructuring.
    // 匿名结构体（元组）字面量和解构。
    const pair = .{ "x", 42 };
    const name = @field(pair, "0");
    const value = @field(pair, "1");
    std.debug.print("pair[0]={s} pair[1]={d} via names: {s}/{d}\n", .{ @field(pair, "0"), @field(pair, "1"), name, value });
}