小编yyy*_*yyy的帖子

一个简单的例子:

struct A;

fn main() {
    test(2);
    test(1);
}

fn test(i: i32) {
    println!("test");
    let a = A;
    if i == 2 {
        us(a);
    }
    println!("end");
}

impl Drop for A {
    fn drop(&mut self) {
        println!("drop");
    }
}

#[allow(unused_variables)]
fn us(a: A){
    println!("use");
}

当我运行它时,输出是:

test
use
drop
end
test
end
drop

我理解在这种test(2)情况下,a被移动us(a),所以它的输出是"test-use-drop-end".

但是,在test(1)输出中,输出是"test-end-drop",这意味着编译器知道a没有移动.

如果us(a)被调用时,就不用砸a在test(i),它会被丢弃在us(a); 如果us(a)没有被调用,a必须在之后删除println!("end") …

在Java中,此代码不起作用:

public <T> void foo() { print(T.class); } // compile time error

因为泛型类型T在运行时被删除.要使用T,我必须使用它作为参数,它将推String.class入堆栈

public <T> void foo(Class<T> T) { print(T); }
public void bar() { foo(String.class); }

但在C#中,我可以在运行时获取类型参数:

public void Foo<T>() { print(typeof(T)); }

它是如何工作的？编译器(或vm)是否自动转换void Foo<T>()为void Foo(Type T)？

更新:

我反汇编了字节码,得到了类似的东西:

ldtoken    !!T
call       System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)

由于ldtoken是"将元数据令牌转换为其运行时表示"的指令,因此很明显运行时类型T存储为元数据.

我猜每个方法都有自己的"元数据表"(或类似的东西),所以调用Foo<string>()并Foo<object>()生成两个"方法句柄"和两个"元数据表",但共享相同的机器代码.是吗？

给出以下 golang 代码：

type Pointer struct { x, y int }

func foo(p *Pointer) *int {
    return &p.y
}

CompilerExplorer显示return &p.y编译为

TESTB   AL, (AX)
ADDQ    $8, AX
RET

这很容易理解。TESTB是空检查，然后通过添加to的偏移量来ADDQ生成指向的指针。p.yPointer::yp

我不明白的是，给定一个指向 的指针p.y，垃圾收集器如何知道它不仅仅是一个任意的*int，而是一个指向 a 的指针Pointer::y，因此p只要指向的指针p.y仍然存在，它就必须保持活动状态？