所有权与内存管理

内存管理基础概念

栈内存 vs 堆内存

值语义 vs 引用语义

这是 Mojo 内存模型的核心概念，理解这对区别是掌握所有权系统的基础：

# 值语义（Value Semantics）
# 赋值时产生独立副本
var a = 42
var b = a    # b 是 a 的副本
b = 100      # 只改变 b
print(a)    # 42（a 不受影响）

# Mojo struct 默认是值语义
var v1 = Vector2D(1.0, 2.0)
var v2 = v1   # 完整复制
v2.x = 99.0  # 只改 v2
print(v1.x)  # 1.0（v1 不变）

# Python 引用语义（参考对比）
# 赋值时共享引用
a = [1, 2, 3]
b = a        # b 指向同一对象
b.append(4) # 通过 b 修改
print(a)   # [1, 2, 3, 4]！
            # a 也被改了
# Python 这种行为常导致难以发现的 bug

三种参数约定：owned、borrowed、inout

核心设计思想

Mojo 函数的每个参数都有明确的所有权约定（ownership convention），通过关键字声明，编译器据此做内存安全检查和优化。

三种约定的代码示例

struct BigData:
    var values: List[Float64]

    fn __init__(inout self, size: Int):
        self.values = List[Float64](size)

# 1. borrowed（默认）：只读访问，无拷贝
fn compute_sum(data: BigData) -> Float64:
    # data 是借用，不能修改 data
    var total: Float64 = 0.0
    for v in data.values:
        total += v[]
    return total

# 2. inout：可修改引用
fn normalize(inout data: BigData):
    # 可以直接修改 data.values
    var total = compute_sum(data)
    for i in range(len(data.values)):
        data.values[i] = data.values[i] / total

# 3. owned：获取所有权
fn consume_and_process(owned data: BigData) -> Float64:
    # data 的所有权已转移到这个函数
    var result = compute_sum(data)
    # 函数结束，data 在这里被析构
    return result

fn main():
    var d = BigData(1000)

    # 调用 borrowed 函数：d 依然有效
    let s = compute_sum(d)

    # 调用 inout 函数：d 被修改
    normalize(d)

    # 调用 owned 函数：d 的所有权被转移
    let r = consume_and_process(d^)  # ^ 表示显式转移所有权
    # 之后不能再使用 d！

生命周期与析构 __del__

struct ManagedBuffer:
    var ptr: UnsafePointer[Float32]
    var size: Int

    fn __init__(inout self, size: Int):
        self.size = size
        # 分配堆内存
        self.ptr = UnsafePointer[Float32].alloc(size)
        print("分配", size, "个 Float32")

    fn __del__(owned self):
        # 析构函数：对象离开作用域时自动调用
        self.ptr.free()
        print("释放", self.size, "个 Float32")

fn main():
    print("开始")
    {
        var buf = ManagedBuffer(1024)
        print("使用 buf")
        # buf 在这里离开作用域，__del__ 自动调用
    }
    print("结束")
    # 输出：
    # 开始
    # 分配 1024 个 Float32
    # 使用 buf
    # 释放 1024 个 Float32
    # 结束

UnsafePointer：底层内存操作

什么时候使用 UnsafePointer？

UnsafePointer 是 Mojo 中逃逸所有权系统、直接操作裸内存的工具。名字中的 "Unsafe" 是明确警告：使用它需要开发者手动保证内存安全，编译器不再保护你。

合理使用场景：实现高性能数据结构（自定义内存布局）、与 C 库交互（FFI）、SIMD 内存加载/存储、绝对不允许拷贝开销的热路径。

fn unsafe_pointer_demo():
    # 分配 8 个 Float32 的连续内存
    var ptr = UnsafePointer[Float32].alloc(8)

    # 初始化内存（必须手动，否则是垃圾值）
    for i in range(8):
        ptr[i] = Float32(i) * 1.5

    # 读取内存
    for i in range(8):
        print(ptr[i], end=" ")  # 0.0 1.5 3.0 4.5 ...

    # 指针算术：偏移访问
    var mid_ptr = ptr + 4    # 指向第 5 个元素
    print(mid_ptr[0])       # 6.0

    # 必须手动释放！（否则内存泄漏）
    ptr.free()

Mojo vs Rust 所有权模型对比