一个学习类型擦除接口时发现的奇怪现象

[TongVan520]

考虑以下代码：
Zig 版本：0.14.0

const std = @import("std");

test "指针" {
    const Base = struct {
        const Self = @This();

        object: *anyopaque,
        interface: struct {
            show: *const fn (object: *const anyopaque) void,
        },

        pub fn show(self: Self) void {
            self.interface.show(self.object);
        }
    };

    const Child = struct {
        const Self = @This();

        number: usize,

        pub fn makeBase(self: Self) Base {
            return (Base{
                .object = @constCast(&self),
                .interface = .{
                    .show = struct {
                        fn f(object: *const anyopaque) void {
                            const s: *const Self = @ptrCast(@alignCast(object));
                            s.show();
                        }
                    }.f,
                },
            });
        }

        // pub fn makeBase(self: *Self) Base {
        //     return (Base{
        //         .object = self,
        //         .interface = .{
        //             .show = struct {
        //                 fn f(object: *const anyopaque) void {
        //                     const s: *const Self = @ptrCast(@alignCast(object));
        //                     s.show();
        //                 }
        //             }.f,
        //         },
        //     });
        // }

        pub fn show(self: Self) void {
            std.debug.print("self.number == {d}\n", .{self.number});
        }
    };

    var child = Child{ .number = 114514 };
    var base = child.makeBase();
    const new_child: *Child = @ptrCast(@alignCast(base.object));
    child.show();
    base.show();
    new_child.show();

    std.debug.print("&child == \n\t{*}\n", .{&child});
    std.debug.print("new_child == \n\t{*}\n", .{new_child});

    // try std.testing.expect(&child == new_child);

    std.debug.print("child memory == \n\t{any}\n", .{std.mem.asBytes(&child)});
    std.debug.print("new_child memory == \n\t{any}\n", .{std.mem.asBytes(new_child)});

    std.debug.print("child.number == \n\t{d}\n", .{child.number});
    std.debug.print("new_child.number == \n\t{d}\n", .{new_child.number});

    try std.testing.expect(child.number == new_child.number);
}

代码简要描述

Child 实现了 Base 的接口 show 。
Base.object 是一个指向 Child 对象的 类型擦除 指针。

由于 makeBase(self: Self) 传入的不是指针，因此在 .object = @constCast(&self) 时， object 保存的是 副本 的地址。

因此下面的 new_child 是一个指向 副本地址的指针 。

疑问

按照我的理解，既然是副本，那么 new_child 指向的地址所存放的数据 应该与 child 完全相同 才对。

测试输出：

test
└─ run test 0/1 passed, 1 failed
error: 'main.test.指针' failed: self.number == 114514
self.number == 114514
self.number == 114514
&child ==
        main.test.指针.Child@f7299ff0d8
new_child ==
        main.test.指针.Child@f7299ff078
child memory ==
        { 82, 191, 1, 0, 0, 0, 0, 0 }
new_child memory ==
        { 240, 34, 186, 146, 247, 127, 0, 0 }
child.number ==
        114514
new_child.number ==
        140701295321840
D:\Complier\Zig\zig\lib\std\testing.zig:580:14: 0x7ff792ba102f in expect (test.exe.obj)
    if (!ok) return error.TestUnexpectedResult;
             ^
D:\Application Projects\CLion\Zig\Tetris\src\main.zig:283:5: 0x7ff792ba11f8 in test.指针 (test.exe.obj)
    try std.testing.expect(child.number == new_child.number);
    ^

三个 show() 都打印了相同的值，这是预期之中的。
但是为什么 new_child.number 与 child.number 不相同呢？
既然 new_child.number 是一串奇怪的数字，那么为什么在调用 new_child.show() 的时候又输出了 期望的 114514 呢？

[w568w]

pub fn makeBase(self: Self) Base

这里是传值，但复制后的副本在栈上。当 makeBase 函数返回时，self 就会从栈中弹出（销毁）。之后该地址即为垃圾值。

[TongVan520]

感谢回答，不过我还是不太清楚：
在 std.heap.GeneralPurposeAllocator 中， allocator 函数的源码是：

pub fn allocator(self: *Self) Allocator {
    return .{
        .ptr = self,
        .vtable = &.{
            .alloc = alloc,
            .resize = resize,
            .remap = remap,
            .free = free,
        },
    };
}

这是写在标准库里的代码，那么为什么 vtable 保存一个 临时对象的地址 又是安全的呢？
这个同样也在 栈 上的 临时对象 应该也会 随着函数返回被销毁 才对。

[w568w]

感谢回答，不过我还是不太清楚： 在 std.heap.GeneralPurposeAllocator 中， allocator 函数的源码是：

...
这是写在标准库里的代码，那么为什么 vtable 保存一个 _临时对象_的地址 又是安全的呢？ 这个同样也在 栈 上的 临时对象 应该也会 随着函数返回被销毁 才对。

这段代码里的匿名对象不是在栈上的，这是因为它的所有成员都是 const 的，故它是 comptime 的。你可以粗略理解为：

const anony_vtable = VTable { // <- 这是 const 的，因为 alloc、resize…… 都是编译期已知的符号
    .alloc = alloc,
    .resize = resize,
    .remap = remap,
    .free = free,
};
// ...
pub fn allocator(self: *Self) Allocator {
    return .{ // <- 这不是静态的，因为 self 的值是动态传入的
        .ptr = self,
        .vtable = &anony_vtable,
    };
}

这种事情的发生是因为：

Local Variables:

When a local variable is const, it means that after initialization, the variable's value will not change. If the initialization value of a const variable is comptime-known, then the variable is also comptime-known.

不过，我没有找到为什么「comptime-known variable 一定会被放在静态不可变内存区域」的解释，希望有其他人能指出来。:)

[jiacai2050]

不过，我没有找到为什么「comptime-known variable 一定会被放在静态不可变内存区域」的解释，希望有其他人能指出来。:)

ziggit 里有些讨论也可以看看：

• https://ziggit.dev/t/diving-deep-into-anonymous-struct-literals/2931
• https://ziggit.dev/t/allocator-vtable-creation-in-standard-library/5435/3

在文档的 Where-are-the-bytes 小节里有这么一句：

Just like string literals, const declarations, when the value is known at comptime, are stored in the global constant data section. Also Compile Time Variables are stored in the global constant data section.

var declarations inside functions are stored in the function's stack frame. Once a function returns, any Pointers to variables in the function's stack frame become invalid references, and dereferencing them becomes unchecked Illegal Behavior.

[zhylmzr]

https://github.com/ziglang/zig/blob/927f233ff82bd422b387b4eef7fcbc67823e4b85/src/Sema.zig#L20082C1-L20101C7

在结构体初始化时会检测每个字段，如果每个字段都编译时已知，那么初始化结果就是对一个常量的引用。