Skip to content
shug的笔记集合

Zig语言

Zig 的语法设计简洁直观，旨在提供高效、易读和安全的编程体验。以下是对 Zig 语法的详细介绍：

注释

单行注释

单行注释以 // 开头，从 // 到行末的所有内容都会被视为注释。

const std = @import("std");


fn main() void {
    // 这是一个单行注释
    const a = 10; // 变量 a 被赋值为 10


    // 打印变量 a 的值
    std.debug.print("a = {}\n", .{a});
}

多行注释

多行注释以 /* 开头，以 */ 结束，注释内容可以跨越多行。

const std = @import("std");


fn main() void {
    /*
     * 这是一个多行注释
     * 你可以在这里写多行内容
     * 注释内容会一直持续到遇到 `*/`
     */
    const b = 20;


    /*
     * 多行注释也可以包含单行注释的样式
     * // 例如这个单行注释
     */
    std.debug.print("b = {}\n", .{b});
}

嵌套注释

Zig 允许嵌套多行注释，这在临时禁用代码块或调试时非常有用。

const std = @import("std");


fn main() void {
    const c = 30;


    /*
    std.debug.print("This will not be printed\n", .{});


    /* 嵌套的多行注释 */
    std.debug.print("c = {}\n", .{c});
    */
}

在上面的代码中，嵌套的多行注释使得整个注释块内的代码都不会被执行。

注释的最佳实践

  1. 解释代码意图：注释应解释代码的意图，而不仅仅是重复代码的字面意思。
  2. 保持简洁：注释应简洁明了，避免冗长。
  3. 更新注释：在修改代码时，确保相应的注释也被更新。
  4. 使用 TODO 注释：使用 TODO 注释标记需要进一步改进或实现的地方。
const std = @import("std");


fn main() void {
    // TODO: 优化这个算法
    const result = someFunction();
    std.debug.print("result = {}\n", .{result});
}


fn someFunction() i32 {
    // 这是一个简单的函数，返回 42
    return 42;
}

变量声明

Zig 的变量声明语法简洁且灵活，支持显式类型声明和类型推断。以下是对 Zig 变量声明的详细介绍：

基本变量声明

常量声明

使用 const 关键字声明常量。常量一旦声明，其值不可更改。

const x: i32 = 42;  // 显式类型声明
const y = 3.14;     // 类型推断为 f64

变量声明

使用 var 关键字声明变量。变量的值可以在程序运行过程中改变。

var a: i32 = 10;  // 显式类型声明
var b = 20;       // 类型推断为 i32

变量的类型推断

Zig 编译器可以根据初始值自动推断变量的类型。以下是一些例子：

const pi = 3.14159;  // 类型推断为 f64
var counter = 0;     // 类型推断为 i32

指针变量

Zig 支持指针变量，用于引用内存地址。使用 * 符号表示指针类型。

var number: i32 = 10;
var ptr: *i32 = &number;  // ptr 是一个指向 number 的指针

数组变量

Zig 支持定长数组和切片（slice）变量。

const array: [5]i32 = [_]i32{1, 2, 3, 4, 5};  // 定长数组
var slice = array[0..];                       // 数组切片

结构体变量

Zig 允许声明和使用结构体类型的变量，用于组织相关的数据。

const std = @import("std");


const Person = struct {
    name: []const u8,
    age: u32,
};


fn main() void {
    const alice = Person{ .name = "Alice", .age = 30 };
    var bob = Person{ .name = "Bob", .age = 25 };


    std.debug.print("{} is {} years old\n", .{alice.name, alice.age});
}

可选变量

Zig 支持可选类型（optional），表示变量可能有值，也可能没有值。使用 ? 表示可选类型。

var maybeNumber: ?i32 = null;  // 可选的 i32 类型变量，初始值为 null
maybeNumber = 10;              // 赋值为 10

示例代码

下面是一个包含各种变量声明的完整示例：

const std = @import("std");


fn main() void {
    // 常量声明
    const pi: f64 = 3.14159;
    const maxItems = 100;  // 类型推断为 i32


    // 变量声明
    var counter: i32 = 0;
    var factor = 2.5;  // 类型推断为 f64


    // 指针变量
    var number: i32 = 42;
    var ptr: *i32 = &number;


    // 数组和切片
    const numbers: [5]i32 = [_]i32{1, 2, 3, 4, 5};
    var slice = numbers[0..];


    // 结构体变量
    const Point = struct {
        x: i32,
        y: i32,
    };
    var origin = Point{ .x = 0, .y = 0 };


    // 可选变量
    var maybeValue: ?i32 = null;
    maybeValue = 10;


    // 输出变量值
    std.debug.print("pi: {}\n", .{pi});
    std.debug.print("counter: {}\n", .{counter});
    std.debug.print("number: {}\n", .{number});
    std.debug.print("first element of slice: {}\n", .{slice[0]});
    std.debug.print("origin: ({}, {})\n", .{origin.x, origin.y});
    if (maybeValue) |value| {
        std.debug.print("maybeValue: {}\n", .{value});
    } else {
        std.debug.print("maybeValue is null\n", .{});
    }
}

数据类型

以下是 Zig 数据类型的表格，并与 C 语言的对应类型进行对比。此表格涵盖了常见的基础类型、浮点类型、布尔类型和指针类型。

Zig 类型描述C 类型示例
整数类型
iNN 位有符号整数无直接对应const a: i12 = -128;
uNN 位无符号整数无直接对应const a: u12 = 128;
i88 位有符号整数int8_t / signed charconst a: i8 = -128;
i88 位有符号整数int8_t / signed charconst a: i8 = -128;
u88 位无符号整数uint8_t / unsigned charconst b: u8 = 255;
i1616 位有符号整数int16_t / shortconst c: i16 = 32767;
u1616 位无符号整数uint16_t / unsigned shortconst d: u16 = 65535;
i3232 位有符号整数int32_t / intconst e: i32 = -2147483648;
u3232 位无符号整数uint32_t / unsigned intconst f: u32 = 4294967295;
i6464 位有符号整数int64_t / long longconst g: i64 = 9223372036854775807;
u6464 位无符号整数uint64_t / unsigned long longconst h: u64 = 18446744073709551615;
i128128 位有符号整数__int128const h: i128 = 18446744073709551615;
u128128 位无符号整数unsigned __int128 const h: u128 = 18446744073709551615;
isize有符号指针大小的整数intptr_t const h: isize = 18446744073709551615;
usize无符号指针大小的整数uintptr_t / size_tconst h: usize = 18446744073709551615;
c_char与c语言的char兼容charconst h: char = 1;
c_short与c语言的short兼容shortconst h: c_short = 1;
c_ushort与c语言的unsigned short兼容unsigned shortconst h: c_ushort = 1;
c_int与c语言的int兼容intconst h: c_int = 1;
c_uint与c语言的unsigned int兼容unsigned intconst h: c_uint = 1;
c_long与c语言的long兼容longconst h: c_long = 1;
c_ulong与c语言的unsigned long兼容unsigned longconst h: c_ulong = 1;
c_longlong与c语言的long long兼容long longconst h: c_longlong = 1;
c_ulonglong与c语言的unsigned long long兼容unsigned long long const h: c_ulonglong = 1;
浮点类型
f1616 位浮点数无直接对应（半精度）const i: f16 = 1.5;
f3232 位浮点数floatconst j: f32 = 3.14;
f6464 位浮点数doubleconst k: f64 = 2.71828;
f8080 位浮点数无直接对应const k: f80 = 2.71828;
f128128 位浮点数无直接对应const k: f128 = 2.71828;
c_longdouble与c语言的long double兼容long doubleconst k: c_longdouble = 2.71828;
布尔类型
bool布尔类型，值为 true 或 false_Bool / boolconst l: bool = true;
指针类型
*T指向类型 T 的指针T*var m: *i32 = &n;
?*T可选指针，指向类型 T 或者 nullT* 或 NULLvar o: ?*i32 = null;
[*]T指向类型 T 的数组的指针T*const p: [*]const u8 = "hello";
数组和切片
[N]T定长数组，包含 N 个类型 T 的元素T[N]const q: [3]i32 = [3]i32{1, 2, 3};
[]T切片，动态长度数组，包含类型 T 的元素无直接对应var r: []i32 = q[0..];
结构体类型
struct结构体类型，包含多个字段structconst Point = struct { x: i32, y: i32 };
联合类型
union联合类型，共享同一内存位置的多个字段unionconst MyUnion = union { a: i32, b: f32 };
可选类型
?T可选类型，包含类型 T 或者 nullT 或 NULLvar s: ?i32 = null;
错误类型
!T错误类型，返回类型 T 或者错误int / errnofn foo() !void { return error.Failed; }
其他类型
void无返回值类型voidfn bar() void {}
noreturn不返回类型，表示函数不会返回void（用于 exit 等函数）fn terminate() noreturn {}
anyopaque用于类型擦除指针void与c语言void互操作
type类型的类型无直接对应
anyerror类型的类型无直接对应
comptime_int仅允许使用comptime已知值。整数字面量的类型无直接对应
comptime_float仅允许使用comptime已知值。浮点文字的类型无直接对应

示例代码

以下是一个包含多种数据类型声明的完整示例，并展示了如何与 C 语言类型对应：

const std = @import("std");


// 整数类型
const a: i8 = -128;
const b: u8 = 255;
const c: i16 = 32767;
const d: u16 = 65535;
const e: i32 = -2147483648;
const f: u32 = 4294967295;
const g: i64 = 9223372036854775807;
const h: u64 = 18446744073709551615;


// 浮点类型
const i: f16 = 1.5;
const j: f32 = 3.14;
const k: f64 = 2.71828;


// 布尔类型
const l: bool = true;


// 指针类型
var n: i32 = 42;
var m: *i32 = &n;
var o: ?*i32 = null;
const p: [*]const u8 = "hello";


// 数组和切片
const q: [3]i32 = [3]i32{1, 2, 3};
var r: []i32 = q[0..];


// 结构体类型
const Point = struct {
    x: i32,
    y: i32,
};


// 联合类型
const MyUnion = union {
    a: i32,
    b: f32,
};


// 可选类型
var s: ?i32 = null;


// 错误类型
fn foo() !void {
    return error.Failed;
}


// 示例函数
fn main() void {
    const std = @import("std");


    // 使用结构体
    var point = Point{ .x = 10, .y = 20 };
    std.debug.print("Point: ({}, {})\n", .{point.x, point.y});


    // 使用联合类型
    var my_union = MyUnion{ .a = 10 };
    std.debug.print("Union a: {}\n", .{my_union.a});


    my_union.b = 3.14;
    std.debug.print("Union b: {}\n", .{my_union.b});
}

类型转换

在 Zig 中，类型转换是将一个值从一种数据类型转换为另一种数据类型的过程。Zig 提供了多种类型转换的方法，包括显式类型转换、隐式类型转换、类型推断和使用内置函数进行类型转换。以下是对 Zig 中类型转换的详细介绍。

显式类型转换

显式类型转换需要使用类型转换函数进行明确的转换。Zig 提供了一些内置函数用于类型转换：

  • @intCast: 将整数类型转换为另一种整数类型。
  • @floatCast: 将浮点类型转换为另一种浮点类型。
  • @intToFloat: 将整数类型转换为浮点类型。
  • @floatToInt: 将浮点类型转换为整数类型。

整数类型转换

const std = @import("std");


fn main() void {
    const a: i32 = 42;
    const b: i64 = @intCast(i64, a); // 将 i32 转换为 i64
    std.debug.print("b: {}\n", .{b});
}

浮点类型转换

const std = @import("std");


fn main() void {
    const x: f32 = 3.14;
    const y: f64 = @floatCast(f64, x); // 将 f32 转换为 f64
    std.debug.print("y: {}\n", .{y});
}

整数到浮点类型转换

const std = @import("std");


fn main() void {
    const i: i32 = 10;
    const f: f32 = @intToFloat(f32, i); // 将 i32 转换为 f32
    std.debug.print("f: {}\n", .{f});
}

浮点到整数类型转换

const std = @import("std");


fn main() void {
    const f: f64 = 3.99;
    const i: i32 = @floatToInt(i32, f); // 将 f64 转换为 i32
    std.debug.print("i: {}\n", .{i});
}

指针类型转换

Zig 允许不同指针类型之间的转换，可以使用 @ptrCast 进行指针类型转换。

const std = @import("std");


fn main() void {
    var a: i32 = 42;
    var p: *i32 = &a;
    var q: *u8 = @ptrCast(*u8, p); // 将 *i32 转换为 *u8
    std.debug.print("q: {}\n", .{q});
}

枚举类型转换

枚举类型可以使用 @enumToInt 和 @intToEnum 进行转换。

const std = @import("std");


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


fn main() void {
    const color: Color = Color.Green;
    const color_int: u32 = @enumToInt(u32, color); // 将枚举转换为整数
    std.debug.print("color_int: {}\n", .{color_int});


    const new_color: Color = @intToEnum(Color, 2); // 将整数转换为枚举
    std.debug.print("new_color: {}\n", .{new_color});
}

类型推断

Zig 支持类型推断，编译器可以根据上下文自动推断出变量的类型。尽管这不是严格意义上的类型转换，但在许多情况下可以减少显式类型转换的需要。

const std = @import("std");


fn main() void {
    const x = 42; // 编译器推断 x 的类型为 i32
    const y = 3.14; // 编译器推断 y 的类型为 f64
    std.debug.print("x: {}, y: {}\n", .{x, y});
}

处理错误类型的转换

Zig 的错误处理机制可以通过 catch 关键字进行转换处理。

const std = @import("std");


fn mightFail() !i32 {
    return error.SomeError;
}


fn main() void {
    const result = mightFail() catch |err| {
        std.debug.print("Error: {}\n", .{err});
        return;
    };
    std.debug.print("Result: {}\n", .{result});
}

字符串格式化

在Zig中，字符串格式化可以通过内置的 std.fmt 模块实现。以下是几种常见的字符串格式化方法：

1. 使用 std.fmt 模块的 fmt 函数

这是Zig中用于字符串格式化的主要方式。std.fmt 提供了类似于C语言 printf 风格的格式化方法。

const std = @import("std");


pub fn main() void {
    const name = "Alice";
    const age = 30;
    var buffer: [100]u8 = undefined; // 缓冲区，用于存储格式化后的字符串
    const formattedString = try std.fmt.bufPrint(&buffer, "My name is {} and I am {} years old.", .{name, age});
    std.debug.print("{}\n", .{formattedString});
}

2. 使用 std.fmt 模块的 bufPrint 函数

这种方法适用于将格式化字符串写入到缓冲区中。

const std = @import("std");


pub fn main() void {
    const name = "Alice";
    const age = 30;
    var buffer: [256]u8 = undefined; // 定义缓冲区
    const output = try std.fmt.bufPrint(&buffer, "My name is {} and I am {} years old.", .{name, age});
    std.debug.print("Formatted string: {s}\n", .{output});
}

3. 使用 std.fmt 模块的 print 函数

如果只是简单地将格式化字符串输出到标准输出，可以直接使用 std.fmt.print 函数。

const std = @import("std");


pub fn main() void {
    const name = "Alice";
    const age = 30;
    std.debug.print("My name is {} and I am {} years old.\n", .{name, age});
}

4. 使用 std.mem 模块的字符串操作函数

对于简单的字符串拼接，可以使用 std.mem 模块中的一些基本字符串操作函数。

const std = @import("std");


pub fn main() void {
    const name = "Alice";
    const age = 30;
    var buffer: [100]u8 = undefined;
    const message = std.fmt.bufPrint(&buffer, "My name is {} and I am {} years old.", .{name, age});
    std.debug.print("{s}\n", .{message});
}

运算符

在 Zig 中，运算符是用于执行各种操作的符号或关键词。以下是 Zig 语言中的主要运算符及其用途的表格：

算术运算符

运算符描述示例结果
+加法5 + 38
-减法5 - 32
*乘法5 * 315
/除法6 / 32
%取模（余数）5 % 32
**幂运算2 ** 38
-取负-5-5

关系运算符

运算符描述示例结果
==等于5 == 3false
!=不等于5 != 3true
>大于5 > 3true
<小于5 < 3false
>=大于等于5 >= 3true
<=小于等于5 <= 3false

逻辑运算符

运算符描述示例结果
&&逻辑与true && falsefalse
``逻辑或
!逻辑非!truefalse

位运算符

运算符描述示例结果
&位与5 & 31
``位或5 | 3
^位异或5 ^ 36
~位非~5-6
<<左移5 << 110
>>右移5 >> 12

赋值运算符

运算符描述示例结果
=赋值x = 5x 是 5
+=加并赋值x += 3x 增加 3
-=减并赋值x -= 3x 减少 3
*=乘并赋值x *= 3x 乘以 3
/=除并赋值x /= 3x 除以 3
%=取模并赋值x %= 3x 取模 3

条件运算符

Zig 采用类似于其他语言的条件运算符和语句，但没有传统的三元运算符。使用 if-else 语句实现条件逻辑：

const std = @import("std");


fn main() void {
    const a = 5;
    const b = 3;


    const max = if (a > b) a else b;  // 如果 a 大于 b，max 等于 a，否则等于 b


    std.debug.print("max: {}\n", .{max});
}

特殊运算符

运算符描述示例结果
@内置函数调用前缀@sizeOf(i32)4
?可选类型处理value ? 0value 不是 null 时返回 value，否则返回 0
try错误处理try foo()调用 foo()，如果返回错误，则传播错误
catch捕获错误foo() catch 0调用 foo()，如果返回错误，则返回 0

示例代码

const std = @import("std");


fn main() void {
    const a = 10;
    const b = 3;


    // 算术运算符
    std.debug.print("a + b = {}\n", .{a + b});
    std.debug.print("a - b = {}\n", .{a - b});
    std.debug.print("a * b = {}\n", .{a * b});
    std.debug.print("a / b = {}\n", .{a / b});
    std.debug.print("a % b = {}\n", .{a % b});


    // 关系运算符
    std.debug.print("a == b = {}\n", .{a == b});
    std.debug.print("a != b = {}\n", .{a != b});
    std.debug.print("a > b = {}\n", .{a > b});
    std.debug.print("a < b = {}\n", .{a < b});
    std.debug.print("a >= b = {}\n", .{a >= b});
    std.debug.print("a <= b = {}\n", .{a <= b});


    // 逻辑运算符
    const x = true;
    const y = false;
    std.debug.print("x && y = {}\n", .{x && y});
    std.debug.print("x || y = {}\n", .{x || y});
    std.debug.print("!x = {}\n", .{!x});


    // 位运算符
    std.debug.print("a & b = {}\n", .{a & b});
    std.debug.print("a | b = {}\n", .{a | b});
    std.debug.print("a ^ b = {}\n", .{a ^ b});
    std.debug.print("~a = {}\n", .{~a});
    std.debug.print("a << 1 = {}\n", .{a << 1});
    std.debug.print("a >> 1 = {}\n", .{a >> 1});


    // 赋值运算符
    var c = 5;
    c += 3;
    std.debug.print("c += 3 -> c = {}\n", .{c});
    c -= 2;
    std.debug.print("c -= 2 -> c = {}\n", .{c});
    c *= 2;
    std.debug.print("c *= 2 -> c = {}\n", .{c});
    c /= 3;
    std.debug.print("c /= 3 -> c = {}\n", .{c});
    c %= 2;
    std.debug.print("c %= 2 -> c = {}\n", .{c});


    // 条件运算符
    const max = if (a > b) a else b;
    std.debug.print("max = {}\n", .{max});
}

函数

在 Zig 中，函数是代码的基本构建块，用于执行特定的任务。函数根据其特性和使用方式可以分为多种类型。以下是对 Zig 中函数分类的详细介绍：

基本函数

普通函数

普通函数是最常见的函数类型，用于执行一般任务，可以有参数和返回值。

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

void 函数

void 函数没有返回值，仅执行一些操作。

fn printHello() void {
    const std = @import("std");
    std.debug.print("Hello, World!\n", .{});
}

类型分类

泛型函数

泛型函数可以处理多种类型，通过在函数签名中使用 comptime 关键字定义类型参数。

fn identity(comptime T: type, value: T) T {
    return value;
}

内联函数

内联函数使用 inline 关键字提示编译器将函数体直接嵌入调用点，以减少函数调用的开销。

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

特殊功能分类

编译时函数

编译时函数使用 comptime 关键字，可以在编译时执行。这在元编程中非常有用。

fn factorial(n: comptime_int) comptime_int {
    if (n == 0) return 1;
    return n * factorial(n - 1);
}


const fact_5 = @compileTime(factorial(5));

错误处理函数

错误处理函数返回一个可能包含错误的值，使用 ! 表示。

fn mightFail() !void {
    return error.SomeError;
}


fn main() void {
    if (mightFail()) |err| {
        const std = @import("std");
        std.debug.print("Error: {}\n", .{err});
    }
}

递归函数

递归函数是调用自身的函数，通常用于解决递归定义的问题。

fn factorial(n: u32) u32 {
    if (n == 0) return 1;
    return n * factorial(n - 1);
}

上下文相关分类

成员函数

成员函数是定义在结构体或联合体内的函数，通常操作该结构体或联合体的实例。

const Point = struct {
    x: i32,
    y: i32,


    fn add(self: *Point, other: Point) void {
        self.x += other.x;
        self.y += other.y;
    }
};


fn main() void {
    var p1 = Point{ .x = 1, .y = 2 };
    const p2 = Point{ .x = 3, .y = 4 };
    p1.add(p2);
}

示例代码

下面是一个包含各种类型函数的完整示例：

const std = @import("std");


// 普通函数
fn add(a: i32, b: i32) i32 {
    return a + b;
}


// void 函数
fn printHello() void {
    std.debug.print("Hello, World!\n", .{});
}


// 泛型函数
fn identity(comptime T: type, value: T) T {
    return value;
}


// 内联函数
inline fn multiply(a: i32, b: i32) i32 {
    return a * b;
}


// 编译时函数
fn factorial(n: comptime_int) comptime_int {
    if (n == 0) return 1;
    return n * factorial(n - 1);
}


// 错误处理函数
fn mightFail() !void {
    return error.SomeError;
}


// 递归函数
fn fibonacci(n: u32) u32 {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}


// 成员函数
const Point = struct {
    x: i32,
    y: i32,


    fn add(self: *Point, other: Point) void {
        self.x += other.x;
        self.y += other.y;
    }
};


fn main() !void {
    // 调用普通函数
    const sum = add(5, 3);
    std.debug.print("sum: {}\n", .{sum});


    // 调用 void 函数
    printHello();


    // 调用泛型函数
    const id = identity(i32, 42);
    std.debug.print("identity: {}\n", .{id});


    // 调用内联函数
    const product = multiply(6, 7);
    std.debug.print("product: {}\n", .{product});


    // 编译时函数
    const fact_5 = @compileTime(factorial(5));
    std.debug.print("factorial(5): {}\n", .{fact_5});


    // 错误处理函数
    if (mightFail()) |err| {
        std.debug.print("Error: {}\n", .{err});
    } else {
        std.debug.print("No error\n", .{});
    }


    // 递归函数
    const fib = fibonacci(10);
    std.debug.print("fibonacci(10): {}\n", .{fib});


    // 成员函数
    var p1 = Point{ .x = 1, .y = 2 };
    const p2 = Point{ .x = 3, .y = 4 };
    p1.add(p2);
    std.debug.print("p1: ({}, {})\n", .{p1.x, p1.y});
}

控制流

在 Zig 中，控制流语句用于控制程序的执行顺序，包括条件判断、循环和错误处理等。以下是 Zig 语言中常见的控制流语句及其使用方法的详细介绍：

条件判断

if-else 语句

if-else 语句根据条件表达式的真假执行不同的代码块。

const std = @import("std");


fn main() void {
    const x = 10;
    if (x > 5) {
        std.debug.print("x is greater than 5\n", .{});
    } else {
        std.debug.print("x is not greater than 5\n", .{});
    }
}

嵌套 if-else 语句

可以嵌套多个 if-else 语句以处理多个条件。

const std = @import("std");


fn main() void {
    const x = 10;
    if (x > 5) {
        std.debug.print("x is greater than 5\n", .{});
    } else if (x == 5) {
        std.debug.print("x is equal to 5\n", .{});
    } else {
        std.debug.print("x is less than 5\n", .{});
    }
}

switch 语句

switch 语句用于基于不同的值执行不同的代码块。

const std = @import("std");


fn main() void {
    const x = 2;
    switch (x) {
        1 => std.debug.print("x is 1\n", .{}),
        2 => std.debug.print("x is 2\n", .{}),
        else => std.debug.print("x is something else\n", .{}),
    }
}

循环

while 循环

while 循环在条件为真时重复执行代码块。

const std = @import("std");


fn main() void {
    var i = 0;
    while (i < 5) {
        std.debug.print("i = {}\n", .{i});
        i += 1;
    }
}

for 循环

for 循环用于遍历数组、切片或其他可迭代对象。

const std = @import("std");


fn main() void {
    const array = [_]i32{1, 2, 3, 4, 5};
    for (array) |item, index| {
        std.debug.print("array[{}] = {}\n", .{index, item});
    }
}

提前返回

return

return 语句用于提前终止函数执行并返回结果。

const std = @import("std");


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


fn main() void {
    const result = add(5, 3);
    std.debug.print("Result: {}\n", .{result});
}

断言

assert

assert 用于在调试过程中检查条件是否为真，条件为假时会引发运行时错误。

const std = @import("std");


fn main() void {
    const x = 10;
    assert(x == 10);
    std.debug.print("Assertion passed\n", .{});
}

示例代码

下面是一个综合示例，展示了条件判断、循环和错误处理的使用：

const std = @import("std");


fn main() !void {
    const x = 10;


    // 条件判断
    if (x > 5) {
        std.debug.print("x is greater than 5\n", .{});
    } else {
        std.debug.print("x is not greater than 5\n", .{});
    }


    // while 循环
    var i = 0;
    while (i < 3) {
        std.debug.print("i = {}\n", .{i});
        i += 1;
    }


    // for 循环
    const array = [_]i32{1, 2, 3};
    for (array) |item, index| {
        std.debug.print("array[{}] = {}\n", .{index, item});
    }


    // 提前返回
    return;
}


fn mightFail() !void {
    return error.SomeError;
}

内存管理

在 Zig 中，内存管理是一个关键方面，允许开发者在需要时精确控制内存的分配和释放。Zig 提供了一些内置的内存管理功能，通过显式的内存分配和释放，确保代码的安全性和高效性。以下是关于 Zig 内存管理的详细介绍：

内存分配和释放

使用标准库分配器

Zig 的标准库提供了各种内存分配器，最常用的是 std.heap.page_allocator。可以使用这些分配器来动态分配和释放内存。

const std = @import("std");


fn main() !void {
    const allocator = std.heap.page_allocator;


    // 分配一个包含 10 个 i32 元素的数组
    var array = try allocator.alloc(i32, 10);
    defer allocator.free(array);


    // 初始化数组
    for (array) |*item, index| {
        item.* = @intCast(i32, index);
    }


    // 打印数组
    for (array) |item, index| {
        std.debug.print("array[{}] = {}\n", .{index, item});
    }
}

自定义分配器

可以自定义分配器以满足特定的内存管理需求。例如，可以实现一个简单的分配器来管理固定大小的内存块。

const std = @import("std");


const FixedAllocator = struct {
    memory: [1024]u8,
    used: usize,


    pub fn init() FixedAllocator {
        return FixedAllocator{ .memory = undefined, .used = 0 };
    }


    pub fn alloc(self: *FixedAllocator, size: usize) ?[]u8 {
        if (self.used + size > self.memory.len) return null;
        const ptr = self.memory[self.used..][0..size];
        self.used += size;
        return ptr;
    }
};


fn main() void {
    var allocator = FixedAllocator.init();


    // 分配内存块
    const block1 = allocator.alloc(100) orelse {
        std.debug.print("Failed to allocate memory\n", .{});
        return;
    };


    // 使用内存块
    for (block1) |*byte| {
        byte.* = 0xAA;
    }


    std.debug.print("Memory allocated and initialized\n", .{});
}

内存对齐

Zig 支持显式内存对齐，可以使用 @alignCast 将内存块对齐到特定边界。

const std = @import("std");


fn main() !void {
    const allocator = std.heap.page_allocator;


    // 分配未对齐的内存
    var mem = try allocator.alloc(u8, 1024);
    defer allocator.free(mem);


    // 将内存块对齐到 16 字节边界
    const aligned_mem = @alignCast(16, mem) catch unreachable;
    std.debug.print("Memory aligned to 16 bytes\n", .{});
}

结构体中的内存管理

在结构体中，可以使用内存分配器来管理动态数据，并在结构体销毁时释放内存。

const std = @import("std");


const DynamicArray = struct {
    data: []i32,
    allocator: *std.mem.Allocator,


    pub fn init(allocator: *std.mem.Allocator, size: usize) !DynamicArray {
        return DynamicArray{
            .data = try allocator.alloc(i32, size),
            .allocator = allocator,
        };
    }


    pub fn deinit(self: DynamicArray) void {
        self.allocator.free(self.data);
    }
};


fn main() !void {
    const allocator = std.heap.page_allocator;
    var array = try DynamicArray.init(allocator, 10);
    defer array.deinit();


    // 初始化数据
    for (array.data) |*item, index| {
        item.* = @intCast(i32, index);
    }


    // 打印数据
    for (array.data) |item, index| {
        std.debug.print("data[{}] = {}\n", .{index, item});
    }
}

结构体

在 Zig 中，结构体（struct）是一种用户定义的数据类型，用于将多个相关的数据组合在一起。结构体可以包含字段、方法和嵌套的结构体。结构体在组织和管理数据时非常有用，特别是在处理复杂的数据结构时。以下是对 Zig 结构体的详细介绍。

定义结构体

结构体使用 struct 关键字定义，字段可以是任何类型，包括基本类型、数组、切片、指针、其他结构体等。

const std = @import("std");


const Point = struct {
    x: i32,
    y: i32,
};


fn main() void {
    const p = Point{ .x = 10, .y = 20 };
    std.debug.print("Point: ({}, {})\n", .{p.x, p.y});
}

结构体方法

可以在结构体内定义方法，方法可以访问结构体的字段。方法的第一个参数通常是 self，指向结构体的实例。

const std = @import("std");


const Point = struct {
    x: i32,
    y: i32,


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


fn main() void {
    var p = Point{ .x = 10, .y = 20 };
    p.translate(5, -5);
    std.debug.print("Point: ({}, {})\n", .{p.x, p.y});
}

结构体初始化

结构体可以使用显式初始化列表进行初始化。也可以定义初始化函数进行更复杂的初始化操作。

const std = @import("std");


const Rectangle = struct {
    width: i32,
    height: i32,


    pub fn init(width: i32, height: i32) Rectangle {
        return Rectangle{ .width = width, .height = height };
    }


    pub fn area(self: Rectangle) i32 {
        return self.width * self.height;
    }
};


fn main() void {
    const rect = Rectangle.init(10, 20);
    const area = rect.area();
    std.debug.print("Rectangle area: {}\n", .{area});
}

嵌套结构体

结构体可以嵌套其他结构体，从而构建更复杂的数据结构。

const std = @import("std");


const Point = struct {
    x: i32,
    y: i32,
};


const Circle = struct {
    center: Point,
    radius: i32,


    pub fn init(center: Point, radius: i32) Circle {
        return Circle{ .center = center, .radius = radius };
    }


    pub fn circumference(self: Circle) f64 {
        return 2 * std.math.pi * @intToFloat(f64, self.radius);
    }
};


fn main() void {
    const center = Point{ .x = 0, .y = 0 };
    const circle = Circle.init(center, 10);
    const circumference = circle.circumference();
    std.debug.print("Circle circumference: {}\n", .{circumference});
}

使用 self 和 *self

在结构体方法中，使用 self 表示结构体实例。可以使用 self 和 *self 来访问结构体的字段和方法。

  • self 用于不可变方法，表示当前实例的一个不可变引用。
  • *self 用于可变方法，表示当前实例的一个可变引用。
const std = @import("std");


const Counter = struct {
    count: i32,


    pub fn init() Counter {
        return Counter{ .count = 0 };
    }


    pub fn increment(self: *Counter) void {
        self.count += 1;
    }


    pub fn getCount(self: Counter) i32 {
        return self.count;
    }
};


fn main() void {
    var counter = Counter.init();
    counter.increment();
    counter.increment();
    const count = counter.getCount();
    std.debug.print("Counter: {}\n", .{count});
}

使用默认值初始化结构体字段

在初始化结构体时，可以为字段提供默认值。

const std = @import("std");


const Config = struct {
    debug: bool = false,
    max_connections: i32 = 100,


    pub fn init(debug: bool, max_connections: i32) Config {
        return Config{ .debug = debug, .max_connections = max_connections };
    }
};


fn main() void {
    const default_config = Config{};
    const custom_config = Config.init(true, 200);


    std.debug.print("Default Config - Debug: {}, Max Connections: {}\n", .{default_config.debug, default_config.max_connections});
    std.debug.print("Custom Config - Debug: {}, Max Connections: {}\n", .{custom_config.debug, custom_config.max_connections});
}

错误处理

在 Zig 中，错误处理是语言设计的一部分，通过显式的错误处理机制提高代码的可读性和可靠性。以下是对 Zig 中错误处理的详细介绍，包括错误类型、错误传播、错误捕获、以及错误处理的最佳实践。

错误类型

Zig 使用 error 关键字定义错误类型。错误类型通常用于函数的返回类型，表示函数可能返回一个错误。

const std = @import("std");


const MyError = error{
    InvalidInput,
    OutOfMemory,
    Unknown,
};

错误传播

在 Zig 中，函数可以返回错误，使用 ! 表示返回值可能是一个错误。可以使用 try 关键字来调用可能返回错误的函数，自动传播错误。

fn mightFail(value: i32) !i32 {
    if (value < 0) {
        return error.InvalidInput;
    }
    return value * 2;
}


fn main() !void {
    const result = try mightFail(-1);
    // 如果上面的函数调用返回错误，程序将不会执行到这里
    std.debug.print("Result: {}\n", .{result});
}

错误捕获

可以使用 catch 关键字捕获并处理错误。如果捕获到错误，可以执行特定的代码块来处理错误。

const std = @import("std");


fn mightFail(value: i32) !i32 {
    if (value < 0) {
        return error.InvalidInput;
    }
    return value * 2;
}


fn main() void {
    const result = mightFail(-1) catch |err| {
        std.debug.print("Error: {}\n", .{err});
        return;
    };
    std.debug.print("Result: {}\n", .{result});
}

错误处理示例

下面是一个综合示例，展示了如何在函数中使用错误处理机制，以及如何在主函数中捕获和处理这些错误。

const std = @import("std");


const MyError = error{
    InvalidInput,
    OutOfMemory,
    Unknown,
};


fn process(value: i32) !i32 {
    if (value < 0) {
        return MyError.InvalidInput;
    } else if (value > 100) {
        return MyError.Unknown;
    }
    return value * 2;
}


fn main() void {
    const result = process(150) catch |err| {
        std.debug.print("Error: {}\n", .{err});
        return;
    };
    std.debug.print("Result: {}\n", .{result});
}

使用 defer 和 errdefer

defer 和 errdefer 关键字可以用来确保在函数返回前执行某些操作，常用于资源释放和清理工作。

  • defer 总是在函数返回前执行。
  • errdefer 仅在函数因错误返回时执行。
const std = @import("std");


fn main() !void {
    const allocator = std.heap.page_allocator;
    var buffer1 = try allocator.alloc(u8, 100);
    defer allocator.free(buffer1);


    var buffer2 = try allocator.alloc(u8, 200);
    errdefer allocator.free(buffer2);


    // 模拟错误
    if (true) {
        return error.SomeError;
    }


    std.debug.print("No error occurred\n", .{});
}

使用自定义错误处理函数

可以定义一个函数来处理特定类型的错误，以便在不同的地方重复使用。

const std = @import("std");


const MyError = error{
    InvalidInput,
    OutOfMemory,
    Unknown,
};


fn process(value: i32) !i32 {
    if (value < 0) {
        return MyError.InvalidInput;
    } else if (value > 100) {
        return MyError.Unknown;
    }
    return value * 2;
}


fn handleError(err: MyError) void {
    const std = @import("std");
    switch (err) {
        MyError.InvalidInput => std.debug.print("Invalid input provided\n", .{}),
        MyError.OutOfMemory => std.debug.print("Out of memory\n", .{}),
        MyError.Unknown => std.debug.print("An unknown error occurred\n", .{}),
    }
}


fn main() void {
    const result = process(-10) catch |err| {
        handleError(err);
        return;
    };
    std.debug.print("Result: {}\n", .{result});
}

编译时执行

在 Zig 中，编译时执行（comptime execution）是一个强大的功能，允许在编译期间执行代码。这在元编程、优化和代码生成方面非常有用。以下是对 Zig 编译时执行的详细介绍。

编译时执行概述

编译时执行可以用于：

  • 常量计算
  • 类型检查
  • 元编程
  • 优化代码生成

使用 comptime 关键字

可以使用 comptime 关键字在编译时执行代码。任何在 comptime 块中的代码都会在编译时执行。

编译时常量计算

const std = @import("std");


const factorial_5 = comptimeFactorial(5);


fn comptimeFactorial(n: comptime_int) comptime_int {
    if (n == 0) return 1;
    return n * comptimeFactorial(n - 1);
}


fn main() void {
    std.debug.print("Factorial of 5 is {}\n", .{factorial_5});
}

编译时类型检查

const std = @import("std");


fn generateArray(comptime N: usize) [N]i32 {
    return [_]i32{0} ** N;
}


fn main() void {
    const array = generateArray(5);
    std.debug.print("Array length: {}\n", .{array.len});
}

编译时函数

可以在编译时执行函数，并且可以在函数签名中使用 comptime 关键字指定编译时参数。

const std = @import("std");


fn generateArray(comptime N: usize) [N]i32 {
    return [_]i32{0} ** N;
}


fn main() void {
    const array = generateArray(5);
    std.debug.print("Array length: {}\n", .{array.len});
}

@compileTime 内置函数

@compileTime 可以用于检查代码是否在编译时执行。

const std = @import("std");


fn checkCompileTime() void {
    if (@compileTime()) {
        std.debug.print("This code is executed at compile time\n", .{});
    } else {
        std.debug.print("This code is executed at runtime\n", .{});
    }
}


fn main() void {
    checkCompileTime(); // 运行时调用
    comptime checkCompileTime(); // 编译时调用
}

编译时循环和条件

编译时执行还支持循环和条件语句，用于生成代码。

const std = @import("std");


fn generateSequence(comptime N: usize) [N]i32 {
    var result: [N]i32 = undefined;
    var i: usize = 0;
    while (i < N) : (i += 1) {
        result[i] = @intCast(i32, i * 2);
    }
    return result;
}


fn main() void {
    const sequence = generateSequence(5);
    for (sequence) |value, index| {
        std.debug.print("sequence[{}] = {}\n", .{index, value});
    }
}

使用编译时执行进行元编程

编译时执行特别适合用于元编程，可以生成复杂的数据结构或函数代码。

const std = @import("std");


fn generateStruct(comptime name: []const u8) type {
    return struct {
        const Self = @This();


        pub fn printName() void {
            std.debug.print("Struct name is: {}\n", .{name});
        }
    };
}


const MyStruct = generateStruct("MyStruct");


fn main() void {
    MyStruct.printName();
}

编译时执行和泛型

编译时执行可以与泛型结合使用，根据编译时参数生成不同的代码。

const std = @import("std");


fn createMatrix(comptime Rows: usize, comptime Cols: usize) type {
    return struct {
        data: [Rows][Cols]f32,


        pub fn init() *Self {
            return &Self{
                .data = undefined,
            };
        }


        pub fn print(self: *Self) void {
            for (self.data) |row, i| {
                for (row) |value, j| {
                    std.debug.print("matrix[{}][{}] = {}\n", .{i, j, value});
                }
            }
        }
    };
}


const Matrix2x3 = createMatrix(2, 3);


fn main() void {
    var matrix = Matrix2x3.init();
    matrix.print();
}

泛型和类型推断

在 Zig 中，泛型和类型推断提供了强大的工具来编写灵活且可重用的代码。以下是对 Zig 中泛型和类型推断的详细介绍。

泛型函数

泛型函数允许你编写对多种类型都适用的函数。通过在函数签名中使用 comptime 关键字，可以定义泛型参数。

基本泛型函数

const std = @import("std");


fn identity(comptime T: type, value: T) T {
    return value;
}


fn main() void {
    const int_value = identity(i32, 42);
    const float_value = identity(f32, 3.14);
    std.debug.print("int_value: {}\n", .{int_value});
    std.debug.print("float_value: {}\n", .{float_value});
}

泛型数据结构

可以使用泛型定义数据结构，使其适用于不同类型的数据。

const std = @import("std");


const Stack = struct(comptime T: type) {
    items: []T,
    top: usize,


    pub fn init(allocator: *std.mem.Allocator, capacity: usize) !Stack {
        return Stack{
            .items = try allocator.alloc(T, capacity),
            .top = 0,
        };
    }


    pub fn push(self: *Stack, item: T) !void {
        if (self.top >= self.items.len) {
            return error.StackOverflow;
        }
        self.items[self.top] = item;
        self.top += 1;
    }


    pub fn pop(self: *Stack) !T {
        if (self.top == 0) {
            return error.StackUnderflow;
        }
        self.top -= 1;
        return self.items[self.top];
    }


    pub fn deinit(self: *Stack, allocator: *std.mem.Allocator) void {
        allocator.free(self.items);
    }
};


fn main() !void {
    const allocator = std.heap.page_allocator;


    var int_stack = try Stack(i32).init(allocator, 10);
    defer int_stack.deinit(allocator);


    try int_stack.push(10);
    try int_stack.push(20);
    const value = try int_stack.pop();
    std.debug.print("Popped value: {}\n", .{value});
}

类型推断

Zig 支持类型推断，可以在变量声明时根据初始值自动推断其类型。使用类型推断可以减少代码冗余，提升代码可读性。

基本类型推断

const std = @import("std");


fn main() void {
    const x = 42; // 自动推断为 i32
    const y = 3.14; // 自动推断为 f64
    std.debug.print("x: {}, y: {}\n", .{x, y});
}

函数返回值类型推断

Zig 也支持在函数定义中推断返回值类型。如果返回值类型可以从函数体中推断出来，则可以省略返回值类型。

const std = @import("std");


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


fn main() void {
    const result = add(5, 3);
    std.debug.print("result: {}\n", .{result});
}

泛型与类型推断结合

泛型和类型推断可以结合使用，使函数和数据结构更加灵活和通用。

const std = @import("std");


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


fn main() void {
    const int_max = max(i32, 10, 20);
    const float_max = max(f32, 1.5, 2.5);
    std.debug.print("int_max: {}\n", .{int_max});
    std.debug.print("float_max: {}\n", .{float_max});
}

泛型结构体和类型推断

结合泛型结构体和类型推断，可以创建高度灵活的数据结构。

const std = @import("std");


const Pair = struct(comptime T: type, comptime U: type) {
    first: T,
    second: U,


    pub fn init(first: T, second: U) Pair {
        return Pair{ .first = first, .second = second };
    }
};


fn main() void {
    const pair = Pair(i32, f64).init(10, 3.14);
    std.debug.print("Pair: ({}, {})\n", .{pair.first, pair.second});
}

模块和导入

在 Zig 中，模块和导入机制提供了组织和重用代码的有效方法。模块化设计允许开发者将代码分割成独立的部分，每个部分都有自己的作用域和依赖关系。以下是关于 Zig 中模块和导入机制的详细介绍。

模块

在 Zig 中，模块是代码的一个独立单元，通常对应于一个文件。模块可以包含常量、变量、函数、结构体和其他类型的定义。

创建模块

假设我们有一个名为 math.zig 的模块，包含一些数学函数：

math.zig
pub fn add(a: i32, b: i32) i32 {
    return a + b;
}


pub fn subtract(a: i32, b: i32) i32 {
    return a - b;
}

在这个例子中，math.zig 定义了两个公共函数 add 和 subtract。

导入模块

使用 @import 函数导入模块，并在代码中使用模块中的定义。

导入自定义模块

const std = @import("std");
const math = @import("math.zig");


fn main() void {
    const result1 = math.add(5, 3);
    const result2 = math.subtract(10, 4);
    std.debug.print("5 + 3 = {}\n", .{result1});
    std.debug.print("10 - 4 = {}\n", .{result2});
}

在这个例子中，我们导入了 math.zig 模块，并调用了其中的 add 和 subtract 函数。

导入标准库

Zig 提供了一个强大的标准库，可以通过 @import("std") 导入。

const std = @import("std");


fn main() void {
    const allocator = std.heap.page_allocator;
    const str = "Hello, Zig!";
    const len = std.mem.len(str);
    std.debug.print("Length of '{}': {}\n", .{str, len});
}

在这个例子中，我们使用标准库中的 heap.page_allocator 和 mem.len 函数来分配内存和计算字符串长度。

公共和私有符号

在 Zig 中，可以使用 pub 关键字将模块中的符号声明为公共符号，使其可以被其他模块访问。如果不使用 pub，符号将是私有的，只有在模块内部可以访问。

公共符号

math.zig
pub fn multiply(a: i32, b: i32) i32 {
    return a * b;
}

私有符号

math.zig
const PI = 3.14159;


fn square(a: i32) i32 {
    return a * a;
}

在这个例子中，PI 和 square 是私有的，只有 math.zig 模块内部可以访问。

嵌套模块

可以在模块内部定义子模块，以进一步组织代码。

math.zig
pub const algebra = struct {
    pub fn multiply(a: i32, b: i32) i32 {
        return a * b;
    }
};


pub const geometry = struct {
    pub fn areaOfCircle(radius: f64) f64 {
        return 3.14159 * radius * radius;
    }
};

使用嵌套模块的例子：

const std = @import("std");
const math = @import("math.zig");


fn main() void {
    const product = math.algebra.multiply(4, 5);
    const area = math.geometry.areaOfCircle(3.0);
    std.debug.print("4 * 5 = {}\n", .{product});
    std.debug.print("Area of circle with radius 3.0 = {}\n", .{area});
}

示例项目结构

以下是一个示例项目结构，展示如何组织模块和导入它们：

project/
├── src/
│   ├── main.zig
│   ├── math.zig
│   └── utils.zig

main.zig

const std = @import("std");
const math = @import("math.zig");
const utils = @import("utils.zig");


fn main() void {
    const result1 = math.add(1, 2);
    const result2 = utils.double(result1);
    std.debug.print("1 + 2 = {}\n", .{result1});
    std.debug.print("double of {} = {}\n", .{result1, result2});
}

math.zig

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

utils.zig

pub fn double(value: i32) i32 {
    return value * 2;
}

标准库

Zig 的标准库（Standard Library）提供了一套丰富的功能，涵盖了从基本数据类型和集合到内存管理和 I/O 操作等多个方面。以下是对 Zig 标准库主要模块和功能的详细介绍。

导入标准库

在 Zig 中，标准库可以通过 @import("std") 进行导入：

const std = @import("std");

常见模块

基本模块

  • std.mem: 提供了内存操作函数。
  • std.math: 提供了常见的数学函数和常量。
  • std.c: 提供了 C 标准库的绑定。
  • std.fmt: 提供了字符串格式化函数。

数据结构

  • std.ArrayList: 动态数组，实现了可变长度的数组。
  • std.HashMap: 哈希表，实现了键值对的存储和检索。
  • std.LinkedList: 链表，实现了元素的有序存储。

I/O 操作

  • std.io: 提供了输入输出操作的支持，包括文件读写和标准输入输出。
  • std.fs: 提供了文件系统操作的支持，包括文件和目录的创建、删除等。

并发和同步

  • std.Thread: 提供了线程操作的支持。
  • std.sync: 提供了同步原语，包括互斥锁和条件变量。

标准库使用示例

内存操作

std.mem 提供了一些常用的内存操作函数。

const std = @import("std");


fn main() void {
    const str = "Hello, Zig!";
    const len = std.mem.len(u8, str);
    std.debug.print("Length of '{}': {}\n", .{str, len});
}

数学函数

std.math 提供了常见的数学函数。

const std = @import("std");


fn main() void {
    const x = 3.0;
    const y = std.math.sqrt(x);
    std.debug.print("Square root of {} is {}\n", .{x, y});
}

动态数组

std.ArrayList 提供了动态数组的实现。

const std = @import("std");


fn main() !void {
    const allocator = std.heap.page_allocator;
    var list = std.ArrayList(i32).init(allocator);
    defer list.deinit();


    try list.append(10);
    try list.append(20);
    try list.append(30);


    for (list.items) |item, index| {
        std.debug.print("list[{}] = {}\n", .{index, item});
    }
}

文件操作

std.fs 提供了文件系统操作的支持。

const std = @import("std");


fn main() !void {
    const file = try std.fs.cwd().createFile("example.txt", .{});
    defer file.close();


    try file.write("Hello, Zig!\n");
    std.debug.print("File written successfully\n", .{});
}

线程操作

std.Thread 提供了线程操作的支持。

const std = @import("std");


fn threadFunc(data: *i32) void {
    const value = data.*;
    std.debug.print("Thread received value: {}\n", .{value});
}


fn main() void {
    var value: i32 = 42;
    var thread = try std.Thread.spawn(threadFunc, &value);
    thread.wait();
}

同步原语

std.sync 提供了同步原语，包括互斥锁和条件变量。

const std = @import("std");


const MyStruct = struct {
    lock: std.sync.Mutex,
    value: i32,


    pub fn init() MyStruct {
        return MyStruct{
            .lock = std.sync.Mutex{},
            .value = 0,
        };
    }


    pub fn increment(self: *MyStruct) void {
        self.lock.lock();
        defer self.lock.unlock();
        self.value += 1;
    }
};


fn main() void {
    var myStruct = MyStruct.init();


    const thread = try std.Thread.spawn(fn (data: *MyStruct) void {
        data.increment();
    }, &myStruct);


    thread.wait();
    std.debug.print("Value: {}\n", .{myStruct.value});
}

内置函数

在 Zig 中，内置函数（builtin functions）是由语言本身提供的一组函数，通常用于低级别的操作、类型检查和转换、编译时操作等。内置函数的名称以 @ 开头。以下是对 Zig 中一些常见内置函数的详细介绍及示例。

内置函数分类

类型转换和检查

  • @intCast: 将一个整数类型转换为另一种整数类型。
  • @floatCast: 将一个浮点类型转换为另一种浮点类型。
  • @intToFloat: 将一个整数类型转换为浮点类型。
  • @floatToInt: 将一个浮点类型转换为整数类型。
  • @bitCast: 在不同类型之间进行位级别的转换。
  • @typeOf: 获取值的类型。
  • @sizeOf: 获取类型或值的字节大小。
  • @alignOf: 获取类型或值的对齐要求。
  • @field: 访问结构体的字段。

数学和位操作

  • @minValue: 获取类型的最小值。
  • @maxValue: 获取类型的最大值。
  • @divExact: 整数除法，如果不能整除则引发错误。
  • @divFloor: 向下取整的整数除法。
  • @mod: 获取整数除法的余数。
  • @shlExact: 左移操作，如果移位超出范围则引发错误。
  • @shrExact: 右移操作，如果移位超出范围则引发错误。
  • @bitReverse: 反转位顺序。

编译时操作

  • @compileTime: 判断代码是否在编译时执行。
  • @typeName: 获取类型的名称。
  • @hasField: 判断结构体是否具有某个字段。
  • @fieldParentPtr: 获取包含字段的结构体指针。
  • @inlineCall: 内联调用一个函数。

内存和指针操作

  • @ptrCast: 将指针转换为另一种指针类型。
  • @alignCast: 将指针对齐到指定的边界。
  • @byteOffsetOf: 获取字段在结构体中的字节偏移量。
  • @ptrToInt: 将指针转换为整数。

内置函数示例

类型转换

const std = @import("std");


fn main() void {
    const a: i32 = 42;
    const b: i64 = @intCast(i64, a); // 将 i32 转换为 i64
    std.debug.print("b: {}\n", .{b});
}

获取类型信息

const std = @import("std");


fn main() void {
    const x: f32 = 3.14;
    const type_name = @typeName(@typeOf(x)); // 获取类型名称
    const size = @sizeOf(@typeOf(x)); // 获取类型的字节大小
    std.debug.print("Type: {}, Size: {}\n", .{type_name, size});
}

数学和位操作

const std = @import("std");


fn main() void {
    const min = @minValue(i32); // 获取 i32 的最小值
    const max = @maxValue(i32); // 获取 i32 的最大值
    const result = @divExact(10, 2); // 精确除法
    std.debug.print("min: {}, max: {}, result: {}\n", .{min, max, result});
}

编译时操作

const std = @import("std");


fn main() void {
    if (@compileTime()) {
        std.debug.print("This code is executed at compile time\n", .{});
    } else {
        std.debug.print("This code is executed at runtime\n", .{});
    }
}

内存和指针操作

const std = @import("std");


const Point = struct {
    x: i32,
    y: i32,
};


fn main() void {
    var p: Point = Point{ .x = 10, .y = 20 };
    const ptr: *u8 = @ptrCast(*u8, &p); // 将指针转换为另一种类型的指针
    const x_offset = @byteOffsetOf(Point, "x"); // 获取字段 x 的字节偏移量
    std.debug.print("Pointer: {}, Offset of x: {}\n", .{ptr, x_offset});
}

并发编程

多进程

Zig 编程语言支持多进程编程，可以通过 Zig 提供的标准库和系统调用实现多进程。以下是一个简单的例子，展示如何使用 Zig 创建和管理多个进程。

const std = @import("std");


pub fn main() void {
    const allocator = std.heap.page_allocator;


    // 创建一个进程
    var child_process = std.ChildProcess.init(allocator);
    defer child_process.deinit();


    // 设置要执行的命令
    child_process.argv = &[_][]const u8{
        "echo",
        "Hello, World!",
    };


    // 启动进程
    const result = child_process.spawn();
    if (result != std.os.ok) {
        std.debug.print("Failed to spawn process: {}\n", .{result});
        return;
    }


    // 等待进程结束
    const exit_status = child_process.wait();
    if (exit_status == std.os.WAIT_SUCCESS) {
        std.debug.print("Process finished successfully\n", .{});
    } else {
        std.debug.print("Process failed with status: {}\n", .{exit_status});
    }
}

这个示例展示了如何使用 Zig 创建一个子进程并等待它完成。这个简单的程序会启动一个 echo 命令，然后等待它完成并打印结果。

解释

  1. 初始化和清理：

    • 使用 std.ChildProcess.init 初始化一个子进程对象。
    • 使用 defer child_process.deinit() 确保在程序结束时清理资源。

  2. 设置命令：

    • child_process.argv 设置要执行的命令及其参数，这里是 echo "Hello, World!"。

  3. 启动进程：

    • child_process.spawn() 启动子进程。

  4. 等待进程结束：

    • child_process.wait() 等待子进程结束并获取其退出状态。

多线程

在 Zig 编程语言中，多线程编程可以通过标准库中的 std.Thread 模块来实现。以下是一个简单的例子，展示如何使用 Zig 创建和管理多个线程。

const std = @import("std");


fn threadFunc(arg: usize) void {
    std.debug.print("Hello from thread {}!\n", .{arg});
}


pub fn main() void {
    const num_threads = 4;
    var threads: [num_threads]std.Thread = undefined;


    // 创建多个线程
    for (threads) |*thread, i| {
        thread.* = try std.Thread.spawn(threadFunc, i);
    }


    // 等待所有线程结束
    for (threads) |*thread| {
        try thread.wait();
    }


    std.debug.print("All threads finished!\n", .{});
}

解释

  1. 导入标准库：

    • const std = @import("std"); 导入 Zig 的标准库。

  2. 线程函数：

    • fn threadFunc(arg: usize) void 定义一个线程函数，它接收一个参数 arg，并打印线程的编号。

  3. 主函数：

    • pub fn main() void 定义主函数。

  4. 创建线程数组：

    • var threads: [num_threads]std.Thread = undefined; 定义一个 std.Thread 类型的数组，用于存储线程对象。

  5. 创建多个线程：

    • 使用 for 循环创建多个线程，每个线程运行 threadFunc 函数，并传递线程编号作为参数。

  6. 等待所有线程结束：

    • 使用另一个 for 循环等待所有线程结束，确保主程序在所有线程结束后才退出。

这个例子展示了如何在 Zig 中创建和管理多个线程。你可以根据需要修改线程函数 threadFunc，实现更复杂的并行计算或任务处理。

线程安全和同步

在多线程编程中，线程安全和数据同步是关键问题。Zig 提供了一些工具来帮助实现线程同步，例如 std.Mutex 和 std.Cond.

以下是一个使用 std.Mutex 的例子，展示如何实现线程同步：

const std = @import("std");


const g = struct {
    var counter: i32 = 0;
    mutex: std.Thread.Mutex = std.Thread.Mutex.init(),
};


fn threadFunc(arg: *g) void {
    for (var i: i32 = 0; i < 1000; i += 1) {
        arg.mutex.lock();
        arg.counter += 1;
        arg.mutex.unlock();
    }
}


pub fn main() void {
    const num_threads = 4;
    var threads: [num_threads]std.Thread = undefined;
    var shared_data = g{};


    // 创建多个线程
    for (threads) |*thread| {
        thread.* = try std.Thread.spawn(threadFunc, &shared_data);
    }


    // 等待所有线程结束
    for (threads) |*thread| {
        try thread.wait();
    }


    std.debug.print("Final counter value: {}\n", .{shared_data.counter});
}

异步编程(zig开发中..)