指针与引用 #

def main():
    var ptr = Pointer[Int].alloc(5)
    
    for i in range(5):
        ptr.store(i, i * 10)
    
    for i in range(5):
        print(ptr.load(i))
    
    ptr.free()

main()

def main():
    let int_ptr = Pointer[Int].alloc(1)
    let float_ptr = Pointer[Float64].alloc(1)
    let str_ptr = Pointer[String].alloc(1)
    
    int_ptr.store(0, 42)
    float_ptr.store(0, 3.14)
    str_ptr.store(0, "Hello")
    
    print(int_ptr.load(0))
    print(float_ptr.load(0))
    print(str_ptr.load(0))
    
    int_ptr.free()
    float_ptr.free()
    str_ptr.free()

main()

def main():
    var ptr: Pointer[Int] = nullptr
    
    if ptr == nullptr:
        print("Pointer is null")
    
    ptr = Pointer[Int].alloc(1)
    ptr.store(0, 100)
    print(ptr.load(0))
    ptr.free()

main()

def main():
    let ptr = Pointer[Int].alloc(3)
    
    ptr.store(0, 10)
    ptr.store(1, 20)
    ptr.store(2, 30)
    
    print(ptr.load(0))
    print(ptr.load(1))
    print(ptr.load(2))
    
    ptr.free()

main()

def main():
    let ptr = Pointer[Int].alloc(5)
    
    for i in range(5):
        ptr.store(i, i)
    
    var current = ptr
    for i in range(5):
        print(current.load(0))
        current = current + 1
    
    ptr.free()

main()

def main():
    let ptr = Pointer[Int].alloc(10)
    
    for i in range(10):
        ptr.store(i, i * i)
    
    let offset_ptr = ptr.offset(5)
    for i in range(5):
        print(offset_ptr.load(i))
    
    ptr.free()

main()

def main():
    let size = 100
    let ptr = Pointer[Int].alloc(size)
    
    for i in range(size):
        ptr.store(i, i)
    
    var sum = 0
    for i in range(size):
        sum += ptr.load(i)
    
    print(f"Sum: {sum}")
    ptr.free()

main()

def main():
    var ptr = Pointer[Int].alloc(5)
    
    for i in range(5):
        ptr.store(i, i)
    
    ptr = ptr.realloc(10)
    
    for i in range(5, 10):
        ptr.store(i, i)
    
    for i in range(10):
        print(ptr.load(i))
    
    ptr.free()

main()

def main():
    let src = Pointer[Int].alloc(5)
    let dst = Pointer[Int].alloc(5)
    
    for i in range(5):
        src.store(i, i * 10)
    
    Pointer.memcpy(dst, src, 5)
    
    for i in range(5):
        print(dst.load(i))
    
    src.free()
    dst.free()

main()

def main():
    var value = 42
    ref value_ref = value
    
    print(value_ref)
    
    value_ref = 100
    print(value)

main()

fn modify(ref x: Int):
    x = x * 2

def main():
    var num = 10
    modify(num)
    print(num)

main()

struct Container:
    var value: Int
    
    fn __init__(inout self, value: Int):
        self.value = value
    
    fn get_ref(ref self) -> ref Int:
        return self.value

def main():
    var c = Container(42)
    ref v = c.get_ref()
    print(v)

main()

def main():
    let ptr = Pointer[Int].alloc(1)
    
    unsafe:
        ptr.store(0, 100)
        print(ptr.load(0))
    
    ptr.free()

main()

fn unsafe_operation() -> Int:
    unsafe:
        let ptr = Pointer[Int].alloc(1)
        ptr.store(0, 42)
        let value = ptr.load(0)
        ptr.free()
        return value

def main():
    print(unsafe_operation())

main()

def main():
    let int_ptr = Pointer[Int].alloc(1)
    int_ptr.store(0, 0x41424344)
    
    unsafe:
        let byte_ptr = Pointer[UInt8](int_ptr)
        for i in range(4):
            print(byte_ptr.load(i))
    
    int_ptr.free()

main()

struct Point:
    var x: Int
    var y: Int
    
    fn __init__(inout self, x: Int, y: Int):
        self.x = x
        self.y = y

def main():
    let ptr = Pointer[Point].alloc(1)
    
    ptr.store(0, Point(10, 20))
    
    let p = ptr.load(0)
    print(f"({p.x}, {p.y})")
    
    ptr.free()

main()

struct Point:
    var x: Int
    var y: Int
    
    fn __init__(inout self, x: Int, y: Int):
        self.x = x
        self.y = y

def main():
    var p = Point(10, 20)
    
    let x_ptr = Pointer.address_of(p.x)
    let y_ptr = Pointer.address_of(p.y)
    
    print(x_ptr.load(0))
    print(y_ptr.load(0))

main()

def main():
    let ptr_array = Pointer[Pointer[Int]].alloc(3)
    
    for i in range(3):
        let inner_ptr = Pointer[Int].alloc(1)
        inner_ptr.store(0, i * 10)
        ptr_array.store(i, inner_ptr)
    
    for i in range(3):
        let inner = ptr_array.load(i)
        print(inner.load(0))
        inner.free()
    
    ptr_array.free()

main()

def main():
    let rows = 3
    let cols = 4
    
    let matrix = Pointer[Pointer[Int]].alloc(rows)
    
    for i in range(rows):
        let row = Pointer[Int].alloc(cols)
        for j in range(cols):
            row.store(j, i * cols + j)
        matrix.store(i, row)
    
    for i in range(rows):
        let row = matrix.load(i)
        for j in range(cols):
            print(row.load(j))
        row.free()
    
    matrix.free()

main()

def main():
    let ptr = Pointer[Int].alloc(100)
    defer ptr.free()
    
    for i in range(100):
        ptr.store(i, i)

main()

struct SafeBuffer:
    var ptr: Pointer[Int]
    var size: Int
    
    fn __init__(inout self, size: Int):
        self.size = size
        self.ptr = Pointer[Int].alloc(size)
    
    fn __del__(owned self):
        self.ptr.free()
    
    fn get(self, index: Int) -> Int:
        if index >= 0 and index < self.size:
            return self.ptr.load(index)
        return 0
    
    fn set(inout self, index: Int, value: Int):
        if index >= 0 and index < self.size:
            self.ptr.store(index, value)

def main():
    var buf = SafeBuffer(10)
    
    for i in range(10):
        buf.set(i, i * i)
    
    for i in range(10):
        print(buf.get(i))

main()

def main():
    let data = [1, 2, 3, 4, 5]
    
    for item in data:
        print(item)

main()