结果位置语义
编译期间,每个 Zig 表达式和子表达式都会获得可选的结果位置信息。这些信息规定表达式应该具有的类型(结果类型),以及结果值应放在内存何处(结果位置)。“可选”表示并非每个表达式都具有这些信息,例如赋值给 _ 既不提供表达式类型信息,也不提供存放结果的具体内存位置。
以语句 const x: u32 = 42; 为例,此处的类型标注向初始化表达式 42 提供结果类型 u32,指示编译器将这个最初为 comptime_int 类型的整数强制转换为目标类型。后面会展示更多例子。
这不是实现细节:上述逻辑已写入 Zig 语言规范,是该语言类型推导的主要机制。这个系统统称为“结果位置语义”。
结果类型
结果类型在可能时会递归传播到子表达式。例如,如果表达式 &e 的结果类型为 *u32,那么 e 会获得结果类型 u32,使语言可以在获取引用之前执行该强制转换。
@intCast 等类型转换内置函数会使用结果类型机制。它们不将目标类型作为参数,而是通过结果类型确定目标类型。结果类型通常可以由上下文确定;无法确定时,可以使用 @as 内置函数显式提供。
可以按如下方式拆解一个简单表达式中各组成部分的结果类型:
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;。
当初始化表达式依赖聚合值原来的值时,这有时十分重要。最简单的例子是尝试交换结构体或数组字段;以下逻辑看似正确,实际并不正确:
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 都没有结果位置 |