跳转到内容
语言参考Zig 0.17.1官方原文
test_functions.zig
const std = @import("std");
const builtin = @import("builtin");
const native_arch = builtin.cpu.arch;
const expectEqual = std.testing.expectEqual;
// 函数声明如下
fn add(a: i8, b: i8) i8 {
if (a == 0) {
return b;
}
return a + b;
}
// export 说明符使函数在生成的目标文件中
// 对外可见,并使用 C ABI。
export fn sub(a: i8, b: i8) i8 {
return a - b;
}
// extern 说明符用于声明一个函数,该函数将在静态链接时
// 于链接阶段解析,或在动态链接时
// 于运行时解析。extern 关键字后的引号标识符指定
// 包含该函数的库(例如 "c" -> libc.so)。
// callconv 说明符改变函数调用约定。
extern "kernel32" fn ExitProcess(exit_code: u32) callconv(.winapi) noreturn;
extern "c" fn atan2(a: f64, b: f64) f64;
// @branchHint 内置函数可告知优化器某函数很少调用(“冷”函数)。
fn abort() noreturn {
@branchHint(.cold);
while (true) {}
}
// naked 调用约定使函数不包含任何函数序言或尾声。
// 与汇编集成时,这可能有用。
fn _start() callconv(.naked) noreturn {
abort();
}
// inline 调用约定强制函数在所有调用点内联。
// 如果函数无法内联,就会产生编译时错误。
inline fn shiftLeftOne(a: u32) u32 {
return a << 1;
}
// pub 说明符使函数在导入后可见。
// 其他文件可以使用 @import 并调用 sub2
pub fn sub2(a: i8, b: i8) i8 {
return a - b;
}
// 函数指针以 `*const ` 为前缀。
const Call2Op = *const fn (a: i8, b: i8) i8;
fn doOp(fnCall: Call2Op, op1: i8, op2: i8) i8 {
return fnCall(op1, op2);
}
test "function" {
try expectEqual(11, doOp(add, 5, 6));
try expectEqual(-1, doOp(sub2, 5, 6));
}
命令行
$ zig test test_functions.zig
1/1 test_functions.test.function...OK
All 1 tests passed.

函数体与函数指针有所区别。函数体的类型只能在编译时使用,而函数指针可以在运行时已知。

按值传递参数

整数和浮点数等基本类型作为参数传递时会被复制,函数体中使用该副本。这称为“按值传递”。复制基本类型几乎没有成本,通常只需设置一个寄存器。

结构体、联合和数组有时通过引用传递更高效,因为复制成本可能随大小任意增长。将这些类型作为参数时,Zig 可以选择复制并按值传递,也可以按引用传递,取决于哪种方式更快。参数不可变这一性质,是允许这样实现的原因之一。

test_pass_by_reference_or_value.zig
const Point = struct {
x: i32,
y: i32,
};
fn foo(point: Point) i32 {
// 此处 `point` 可以是引用,也可以是副本。函数体
// 可以忽略这一区别并将其视为值。获取参数地址时
// 必须非常谨慎:应将该地址视为在函数返回后
// 就会失效。
return point.x + point.y;
}
const expectEqual = @import("std").testing.expectEqual;
test "pass struct to function" {
try expectEqual(3, foo(Point{ .x = 1, .y = 2 }));
}
命令行
$ zig test test_pass_by_reference_or_value.zig
1/1 test_pass_by_reference_or_value.test.pass struct to function...OK
All 1 tests passed.

对于 extern 函数,Zig 遵循 C ABI 按值传递结构体和联合。

函数参数类型推导

声明函数参数时可以使用 anytype 代替类型。此时会在调用函数时推导参数类型。使用 @TypeOf 和 @typeInfo 获取推导类型的信息。

test_fn_type_inference.zig
const expectEqual = @import("std").testing.expectEqual;
fn addFortyTwo(x: anytype) @TypeOf(x) {
return x + 42;
}
test "fn type inference" {
try expectEqual(43, addFortyTwo(1));
try expectEqual(comptime_int, @TypeOf(addFortyTwo(1)));
const y: i64 = 2;
try expectEqual(44, addFortyTwo(y));
try expectEqual(i64, @TypeOf(addFortyTwo(y)));
}
命令行
$ zig test test_fn_type_inference.zig
1/1 test_fn_type_inference.test.fn type inference...OK
All 1 tests passed.

inline fn

在函数定义中添加 inline 关键字,会使该函数在调用点进行语义内联。内联不是提示,并非仅供优化阶段酌情采纳;它会影响函数调用中涉及的类型和值。

与普通函数调用不同,内联函数调用点中在编译时已知的实参会被视为编译时参数。这种性质可能一直传播到返回值:

inline_call.zig
const std = @import("std");
pub fn main() void {
if (foo(1200, 34) != 1234) {
@compileError("bad");
}
}
inline fn foo(a: i32, b: i32) i32 {
std.debug.print("runtime a = {} b = {}", .{ a, b });
return a + b;
}
命令行
$ zig build-exe inline_call.zig
$ ./inline_call
runtime a = 1200 b = 34

移除 inline 后,测试将因编译错误而失败,而不是通过。

内联不是提示

使用 inline 会限制编译器可采取的处理方式。这可能损害二进制大小、编译速度,甚至运行时性能。作为交换,它能满足以下用例:

  • 为调试或与汇编集成,确保调用栈中包含特定的栈帧。
  • 如上例所示,强制将调用点恰好在编译时已知的参数信息传播到函数返回值。
  • 绕过编译器后端实现的限制。

如果只想向编译器提示内联函数可能有益,应使用 @branchHint,而非 inline。

函数反射

test_fn_reflection.zig
const std = @import("std");
const math = std.math;
const testing = std.testing;
test "fn reflection" {
try testing.expectEqual(bool, @typeInfo(@TypeOf(testing.expect)).@"fn".param_types[0].?);
try testing.expectEqual(testing.TmpDir, @typeInfo(@TypeOf(testing.tmpDir)).@"fn".return_type.?);
try testing.expect(@typeInfo(@TypeOf(math.Log2Int)).@"fn".is_generic);
}
命令行
$ zig test test_fn_reflection.zig
1/1 test_fn_reflection.test.fn reflection...OK
All 1 tests passed.