用户定义类型

const std = @import("std");

// 第8章 — 结构体基础：字段、方法、默认值、命名空间
//
// 演示如何使用字段和方法定义结构体，包括
// 默认字段值。同时展示方法的命名空间与自由函数的区别。
//
// Usage: 
//    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;
    }
};

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

pub fn main() !void {
    var p = Point{ .x = 3 }; // y uses default 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");

// 第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 });

    // 使用@enumFromInt往返；整数必须映射到声明的标签
    const m2: Mode = @enumFromInt(2);
    std.debug.print("m2={s} int={d}\n", .{ describe(m2), @intFromEnum(m2) });
}

const std = @import("std");

// 第8章 — 联合体：带标签与不带标签
//
// 演示带标签的联合体（使用枚举判别符）和不带标签的联合体
// （无判别符）。带标签的联合体是安全且符合语言习惯的；不带标签的
// 联合体是高级用法，若使用不当则不安全。
//
// 用法:
//    zig run union_demo.zig

const Kind = enum { number, text };

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

// 不带标签的联合体（高级）：需要外部跟踪，若使用不当则不安全。
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);

    // 不带标签的示例：以 u32 写入，以 i32 读取（位重新解释）。
    const r = Raw{ .u = 0xFFFF_FFFE }; // -2 as signed 32-bit
    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 — Layout (packed/extern) 和 anonymous structs/tuples

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.
    // Packed bit-fields combine into 一个 single byte.
    std.debug.print("packed.size={d}\n", .{@sizeOf(Packed)});

    // Extern layout matches the C ABI (padding may be inserted).
    // Extern layout matches C ABI (padding may be inserted).
    std.debug.print("extern.size={d} align={d}\n", .{ @sizeOf(Extern), @alignOf(Extern) });

    // Anonymous struct (tuple) literals and destructuring.
    // Anonymous struct (tuple) literals 和 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 });
}