地址与指针

指针就是拥有类型上下文的地址，告诉编译器以何种类型读写某地址的数据
指针转为地址，去掉类型上下文转为整数即可；地址转指针，加上类型上下文即可

栈上类型地址

栈上类型的局部变量的地址就是其在栈上的地址

var a = 3

let ptr = withUnsafePointer(to: &a) { $0 }
let addr = UInt(bitPattern: ptr)

let ptr2 = UnsafePointer<Int>(bitPattern: addr)!
let a2 = ptr2.pointee

#![allow(unused)]
fn main() {
let a = 3;

let ptr = &a as *const i32;
let addr = ptr as usize;

let ptr = addr as *const i32;
let a = unsafe { *ptr };
}

int a = 3;

int *ptr = &a;
long long addr = (long long)ptr;

int *ptr2 = (int*)addr;
int a2 = *ptr2;

// arm64, AT&T

_main:
    sub sp, sp, #64
    stp x29, x30, [sp, #48]
    add x29, sp, #48


    // int a = 3;
    mov w8, #3
    str w8, [x29, #-4]

    // int *ptr = &a;
    sub x8, x29, #4
    str x8, [x29, #-16]

    // long long addr = (long long)ptr;
    ldr x8, [x29, #-16]
    str x8, [x29, #-24]

    // int *ptr2 = (int*)addr;
    ldr x8, [x29, #-24]
    str x8, [x29, #-32]

    // int a2 = *ptr2;
    ldr x8, [x29, #-32]
    ldr w8, [x8]
    str w8, [x29, #-36]


    ldp x29, x30, [sp, #48]
    add sp, sp, #64

    ret

堆上类型地址

堆上类型的指针变量的地址就是其在栈上的地址
堆上类型的堆内存地址就是指向其堆内存的指针转为地址的值

class C {
    let a: Int
    
    init(a: Int) {
        self.a = a
    }
}

let c = C(a: 3)

let addr = unsafeBitCast(c, to: UInt.self)

let ref = unsafeBitCast(addr, to: C.self)

#![allow(unused)]
fn main() {
struct C {
    a: i32,
}

let c = Box::new(C { a: 3 });

let addr = c.as_ref() as *const C as usize;

let ptr = addr as *const C;
}

struct C {
    int a;
};

struct C *c = malloc(sizeof(struct C));
c->a = 3;

long long addr = (long long)c;

struct C *ptr = (struct C*)addr;