跳转到内容

结果位置语义

语言参考Zig 0.17.1官方原文

编译期间,每个 Zig 表达式和子表达式都会获得可选的结果位置信息。这些信息规定表达式应该具有的类型(结果类型),以及结果值应放在内存何处(结果位置)。“可选”表示并非每个表达式都具有这些信息,例如赋值给 _ 既不提供表达式类型信息,也不提供存放结果的具体内存位置。

以语句 const x: u32 = 42; 为例,此处的类型标注向初始化表达式 42 提供结果类型 u32,指示编译器将这个最初为 comptime_int 类型的整数强制转换为目标类型。后面会展示更多例子。

这不是实现细节:上述逻辑已写入 Zig 语言规范,是该语言类型推导的主要机制。这个系统统称为“结果位置语义”。

结果类型

结果类型在可能时会递归传播到子表达式。例如,如果表达式 &e 的结果类型为 *u32,那么 e 会获得结果类型 u32,使语言可以在获取引用之前执行该强制转换。

@intCast 等类型转换内置函数会使用结果类型机制。它们不将目标类型作为参数,而是通过结果类型确定目标类型。结果类型通常可以由上下文确定;无法确定时,可以使用 @as 内置函数显式提供。

可以按如下方式拆解一个简单表达式中各组成部分的结果类型:

result_type_propagation.zig
const expectEqual = @import("std").testing.expectEqual;
test "result type propagates through struct initializer" {
const S = struct { x: u32 };
const val: u64 = 123;
const s: S = .{ .x = @intCast(val) };
// .{ .x = @intCast(val) } 由类型标注获得结果类型 `S`
// @intCast(val) 由字段 `S.x` 的类型获得结果类型 `u32`
// val 可为任意整数类型,因此没有结果类型
try expectEqual(@as(u32, 123), s.x);
}
命令行
$ zig test result_type_propagation.zig
1/1 result_type_propagation.test.result type propagates through struct initializer...OK
All 1 tests passed.

结果类型信息对上述转换内置函数很有用,还能避免构造强制转换前的值,并在某些情况下省去显式类型强制转换。下表说明常见表达式如何传播结果类型,其中 x 和 y 为任意子表达式。

表达式 父表达式结果类型 子表达式结果类型
const val: T = x - x 的类型为 T
var val: T = x - x 的类型为 T
val = x - x 的类型为 @TypeOf(val)
@as(T, x) - x 的类型为 T
&x *T x 的类型为 T
&x []T x 是元素类型为 T 的某个数组
f(x) - x 的类型为 f 的第一个参数类型
.{x} T x 的类型为 @FieldType(T, "0")
.{ .a = x } T x 的类型为 @FieldType(T, "a")
T{x} - x 的类型为 @FieldType(T, "0")
T{ .a = x } - x 的类型为 @FieldType(T, "a")
@Int(x, y) - x 的类型为 std.lang.Signedness,y 的类型为 u16
@typeInfo(x) - x 的类型为 type
x << y - y 的类型为 std.math.Log2IntCeil(@TypeOf(x))

结果位置

除结果类型信息外,每个表达式还可以获得可选的结果位置,即必须直接写入结果值的指针。初始化数据结构时,这套机制可避免中间复制,对必须具有固定内存地址的类型(“固定”类型)尤其重要。

编译简单赋值表达式 x = e 时,许多语言会先在栈上创建临时值 e,然后赋给 x,期间可能进行类型强制转换。Zig 采用不同方式:表达式 e 获得与 x 类型匹配的结果类型,以及结果位置 &x。对于 e 的许多语法形式,这没有实际影响;但对于更复杂的语法形式,可能产生重要的语义效果。

例如,如果表达式 .{ .a = x, .b = y } 的结果位置为 ptr,则 x 会获得结果位置 &ptr.a,y 会获得结果位置 &ptr.b。没有这一机制时,该表达式会先完整地在栈上构造临时结构体值,再复制到目标地址。实质上,Zig 将赋值 foo = .{ .a = x, .b = y } 去糖为两条语句 foo.a = x; foo.b = y;。

当初始化表达式依赖聚合值原来的值时,这有时十分重要。最简单的例子是尝试交换结构体或数组字段;以下逻辑看似正确,实际并不正确:

result_location_interfering_with_swap.zig
const expectEqual = @import("std").testing.expectEqual;
test "attempt to swap array elements with array initializer" {
var arr: [2]u32 = .{ 1, 2 };
arr = .{ arr[1], arr[0] };
// 前一行等价于以下两行:
// arr[0] = arr[1];
// arr[1] = arr[0];
// 因此这里失败!
try expectEqual(2, arr[0]); // 成功
try expectEqual(1, arr[1]); // 失败
}
命令行
$ zig test result_location_interfering_with_swap.zig
1/1 result_location_interfering_with_swap.test.attempt to swap array elements with array initializer...expected 1, found 2
FAIL (TestExpectedEqual)
/home/alexrp/.cache/zig/p/N-V-__8AALBXTRYsilzupvrmv0afm7ohtj5Mj0paqVfKLmfP/lib/std/testing.zig:93:17: 0x124e984 in expectEqualInner__func_958 (std.zig)
return error.TestExpectedEqual;
^
/home/alexrp/.cache/zig/p/N-V-__8AALBXTRYsilzupvrmv0afm7ohtj5Mj0paqVfKLmfP/lib/std/testing.zig:57:5: 0x124eafd in expectEqual (result_location_interfering_with_swap.zig)
return expectEqualInner(T, expected, actual);
^
/home/alexrp/Sources/ziglang/zig/doc/langref/result_location_interfering_with_swap.zig:10:5: 0x124eb44 in test.attempt to swap array elements with array initializer (result_location_interfering_with_swap.zig)
try expectEqual(1, arr[1]); // fails
^
0 passed; 0 skipped; 1 failed.
error: the following test command failed with exit code 1:
/home/alexrp/Sources/ziglang/zig/.zig-cache/o/4ba2b3a3d843471ad82180c8ba3262f2/test --seed=0x481142ba

下表说明常见表达式如何传播结果位置,其中 x 和 y 为任意子表达式。注意,某些表达式即使自身具有结果位置,也无法向子表达式提供有意义的结果位置。

表达式 结果位置 子表达式结果位置
const val: T = x - x 的结果位置为 &val
var val: T = x - x 的结果位置为 &val
val = x - x 的结果位置为 &val
@as(T, x) ptr x 没有结果位置
&x ptr x 没有结果位置
f(x) ptr x 没有结果位置
.{x} ptr x 的结果位置为 &ptr[0]
.{ .a = x } ptr x 的结果位置为 &ptr.a
T{x} ptr x 没有结果位置(显式指定类型的初始化器不传播结果位置)
T{ .a = x } ptr x 没有结果位置(显式指定类型的初始化器不传播结果位置)
@Int(x, y) - x 和 y 都没有结果位置
@typeInfo(x) ptr x 没有结果位置
x << y ptr x 和 y 都没有结果位置