HoRain云--Zig数据类型全解析

云夏之末

675人浏览 · 2026-04-30 11:15:00

云夏之末 · 2026-04-30 11:15:00 发布

🎬 HoRain云小助手：个人主页

🔥 个人专栏: 《Linux 系列教程》《c语言教程》

⛺️生活的理想，就是为了理想的生活!

⛳️ 推荐

前些天发现了一个超棒的服务器购买网站，性价比超高，大内存超划算！忍不住分享一下给大家。点击跳转到网站。

专栏介绍

专栏名称	专栏介绍
《C语言》	本专栏主要撰写C干货内容和编程技巧，让大家从底层了解C，把更多的知识由抽象到简单通俗易懂。
《网络协议》	本专栏主要是注重从底层来给大家一步步剖析网络协议的奥秘，一起解密网络协议在运行中协议的基本运行机制！
《docker容器精解篇》	全面深入解析 docker 容器，从基础到进阶，涵盖原理、操作、实践案例，助您精通 docker。
《linux系列》	本专栏主要撰写Linux干货内容，从基础到进阶，知识由抽象到简单通俗易懂，帮你从新手小白到扫地僧。
《python 系列》	本专栏着重撰写Python相关的干货内容与编程技巧，助力大家从底层去认识Python，将更多复杂的知识由抽象转化为简单易懂的内容。
《试题库》	本专栏主要是发布一些考试和练习题库（涵盖软考、HCIE、HRCE、CCNA等）

Zig 数据类型

Zig 是一门静态类型、编译型系统编程语言，其类型系统旨在提供精确的内存控制和零开销抽象。

基本数据类型

1. 整数类型

// 有符号整数
const i8: i8 = -128;     // 8位
const i16: i16 = 32767;  // 16位
const i32: i32 = 100;    // 32位
const i64: i64 = 1000;   // 64位
const i128: i128 = 10000;// 128位
const isize: isize = 42; // 指针大小

// 无符号整数
const u8: u8 = 255;      // 8位
const u16: u16 = 65535;  // 16位
const u32: u32 = 100;    // 32位
const u64: u64 = 1000;   // 64位
const u128: u128 = 10000;// 128位
const usize: usize = 42; // 指针大小

2. 浮点数类型

const f16: f16 = 3.14;   // 16位
const f32: f32 = 3.14159; // 32位
const f64: f64 = 3.14159265359;  // 64位
const f128: f128 = 3.14159265358979323846;  // 128位

3. 布尔类型

const is_true: bool = true;
const is_false: bool = false;

复合数据类型

4. 数组

// 固定长度数组
const arr: [5]i32 = [5]i32{1, 2, 3, 4, 5};
const auto_arr = [_]i32{1, 2, 3};  // 自动推断长度

// 多维数组
const matrix: [3][3]f32 = [3][3]f32{
    [_]f32{1.0, 0.0, 0.0},
    [_]f32{0.0, 1.0, 0.0},
    [_]f32{0.0, 0.0, 1.0},
};

5. 切片

const arr = [_]i32{1, 2, 3, 4, 5};
const slice: []const i32 = &arr;  // 只读切片
const mutable_slice: []i32 = &[_]i32{1, 2, 3};  // 可变切片

6. 结构体

const Point = struct {
    x: f32,
    y: f32,
    z: f32 = 0,  // 默认值
    
    // 方法
    pub fn distance(self: Point, other: Point) f32 {
        const dx = self.x - other.x;
        const dy = self.y - other.y;
        return @sqrt(dx * dx + dy * dy);
    }
};

const p1 = Point{ .x = 1.0, .y = 2.0 };
const p2 = Point{ .x = 4.0, .y = 6.0 };
const dist = p1.distance(p2);

7. 联合体

// 标记联合
const Value = union(enum) {
    int: i32,
    float: f64,
    bool: bool,
    string: []const u8,
    
    // 方法
    pub fn print(self: Value) void {
        switch (self) {
            .int => |v| std.debug.print("int: {}\n", .{v}),
            .float => |v| std.debug.print("float: {}\n", .{v}),
            .bool => |v| std.debug.print("bool: {}\n", .{v}),
            .string => |v| std.debug.print("string: {s}\n", .{v}),
        }
    }
};

const v1 = Value{ .int = 42 };
const v2 = Value{ .string = "hello" };

8. 枚举

const Color = enum {
    red,
    green,
    blue,
    
    // 可指定值
    const RGB = enum(u8) {
        red = 0xFF0000,
        green = 0x00FF00,
        blue = 0x0000FF,
    };
};

特殊类型

9. 可选类型

const maybe_int: ?i32 = null;
const some_int: ?i32 = 42;

// 解包可选类型
if (maybe_int) |value| {
    // 有值的情况
} else {
    // 为null的情况
}

10. 错误联合类型

const ErrorType = error{OutOfMemory, FileNotFound, InvalidData};
const ErrorableInt = ErrorType!i32;  // 返回i32或错误

fn mightFail() ErrorableInt {
    return error.OutOfMemory;  // 返回错误
    // 或 return 42;  // 返回值
}

11. 指针类型

var value: i32 = 42;

// 单元素指针
const single_ptr: *i32 = &value;
single_ptr.* = 100;  // 解引用

// 多元素指针
const array = [_]i32{1, 2, 3, 4, 5};
const many_ptr: [*]const i32 = &array;

// 切片指针
const slice_ptr: []const i32 = &array;

// 可选指针
const optional_ptr: ?*i32 = &value;

12. 向量类型（SIMD）

// 4个f32的向量
const vec: @Vector(4, f32) = .{1.0, 2.0, 3.0, 4.0};
const doubled = vec * @splat(4, @as(f32, 2.0));

类型相关操作

13. 类型转换

const a: i32 = 42;
const b: f64 = @floatFromInt(a);  // 整数转浮点
const c: i32 = @intFromFloat(3.14);  // 浮点转整数
const d: usize = @intCast(100);  // 类型转换

14. 编译时类型

const T = i32;  // 类型别名
comptime {
    const size = @sizeOf(i32);  // 编译时计算大小
    const alignment = @alignOf(i32);  // 编译时计算对齐
}

内存布局控制

// 指定对齐
const AlignedStruct = struct {
    data: u64 align(16),  // 16字节对齐
};

// 指定打包
const PackedStruct = packed struct {
    a: u8,
    b: u16,
    c: u32,
};

Zig的类型系统设计强调显式性和安全性，不进行隐式类型转换，强制开发者明确处理类型边界情况，这使得代码更可靠且易于维护。