仓颉白皮书——安全可靠的try-with-resources 与动态安全检查

// 传统写法：手动释放资源（易遗漏）
let input = MyResource()
let output = MyResource()

do {
    while input.hasNextLine() {
        let line = input.readLine()
        output.writeLine(line)
    }
} catch {
    // 处理异常
} finally {
    input.close()  // 必须手动关闭，否则资源泄漏
    output.close() // 若中间代码报错，可能无法执行到这里
}

风险：若 do 块中提前 return 或抛出异常，finally 里的关闭代码可能被跳过。

2. try-with-resources 语法与原理

// try-with-resources 写法：自动释放资源
try (
    input = MyResource(),  // 申请资源，自动管理
    output = MyResource()
) {
    while input.hasNextLine() {
        let line = input.readLine()
        output.writeLine(line)
    }
} catch {
    // 处理异常（可选）
}
// 无需手动关闭资源，离开作用域自动释放

核心逻辑：
1. try 关键字后括号内定义资源变量（如 input、output）。
2. 资源类型必须实现 Resource 接口（需包含 isClosed 属性和 close() 方法）。
3. 无论 try 块是正常结束还是抛出异常，都会自动调用 close() 释放资源。

3. Resource 接口的要求

// 必须实现的接口
interface Resource {
    var isClosed: Bool { get }  // 判断资源是否已关闭
    func close()  // 释放资源的逻辑
}

// 示例：文件资源类
class FileResource : Resource {
    private var handle: FileHandle  // 底层文件句柄

    init(path: String) {
        handle = openFile(path)  // 打开文件
    }

    var isClosed: Bool {
        return handle.isClosed  // 暴露关闭状态
    }

    func close() {
        if !isClosed {
            handle.close()  // 关闭文件句柄
            println("File closed")
        }
    }

    // 其他文件操作方法...
}

为什么需要接口？
统一资源释放的标准，确保 try-with-resources 能通用地管理任何资源。

4. 可选的 catch 和 finally

// 最简形式：只有 try 块
try (resource = MyResource()) {
    // 业务逻辑
}

// 包含 catch 和 finally
try (resource = MyResource()) {
    // 可能抛出异常的代码
} catch let e {
    println("Error: \(e)")  // 处理异常
} finally {
    println("Finally block executed")  // 可选的最终处理
}

执行顺序：
try 块 → 异常时 catch → 最后 finally（若有）→ 自动释放资源。

二、动态安全检查：运行时的 “安全网”

静态类型能在编译期发现类型错误，但有些问题（如整数溢出、数组越界）需在运行时检查。仓颉通过动态检查避免这些隐患。

1. 整数溢出检查：拒绝 “数值陷阱”

传统语言问题：
C++ 中 int8_t x = 127 + 3 会溢出为 -126（静默 wrapping），可能导致逻辑错误。
仓颉默认行为：
整数运算默认开启溢出检查，编译期或运行时抛出异常。
```
let x: Int8 = 127
let y: Int8 = 3
let z = x + y  // ❌ 编译期报错：Int8 溢出
```

允许 wrapping 的场景：
用 @OverflowWrapping 注解关闭检查（牺牲安全换性能）。

@OverflowWrapping
func riskyAdd(x: Int8, y: Int8) -> Int8 {
    return x + y  // 允许溢出，结果为 -126
}

2. 数组越界检查：防止 “内存越界”

编译期检查：
下标为字面量时，编译器直接检查是否越界。

let arr = [1, 2, 3]
let element = arr[5]  // ❌ 编译期报错：下标 5 超出范围（0-2）

运行时检查：
下标为变量时，运行时检查是否越界，抛出 IndexOutOfBoundsException。

func accessElement(index: Int) {
    let arr = [1, 2, 3]
    let element = arr[index]  // 运行时检查 index 是否在 0-2 之间
}

accessElement(index: -1)  // 运行时抛出异常

3. 动态检查的性能影响

开销控制：
仓颉编译器会优化常见场景，例如：
- 已知下标范围的循环，自动省略运行时检查。
- 静态可分析的整数运算，提前报错避免运行时开销。
权衡建议：
- 业务逻辑优先使用默认检查（安全第一）。
- 高性能场景（如底层库）使用 @OverflowWrapping 或静态数组下标。

三、关键对比表：传统语言 vs. 仓颉

特性	传统语言（如 C++/Java）	仓颉	优势
资源释放	手动调用 `close()`，易泄漏	`try-with-resources` 自动释放	避免 90% 资源泄漏问题
整数溢出处理	静默 wrapping，隐藏风险	默认检查，编译期 / 运行时报错	提前发现数值计算错误
数组越界处理	运行时崩溃或未定义行为	编译期 / 运行时检查，抛出明确异常	定位问题更精准
动态检查性能	无检查或少量检查	优化后开销低（接近传统语言）	安全与性能平衡

四、初学者实践建议

总是使用 try-with-resources 管理资源：
- 只要涉及文件、网络等资源，优先用 try (...) { ... } 结构。
```
try (file = FileResource("data.txt")) {
    // 读写文件逻辑
}
```
理解溢出风险：
- 对数值计算结果保持警惕，不确定时用 @OverflowWrapping 注解。

数组下标谨慎处理：

循环中使用 arr.indices 确保下标合法。

for i in arr.indices {
    let element = arr[i]  // 安全下标范围
}

异常处理策略：
- 优先在 try-with-resources 中处理异常，避免多层嵌套。

五、常见错误与解决

错误信息	原因	解决方法
`Resource type does not conform to Resource`	资源类未实现 Resource 接口	为类添加 `isClosed` 和 `close()`
`Integer overflow in expression`	整数运算溢出	扩大类型（如 Int8 → Int16）或添加 `@OverflowWrapping`
`Index out of bounds`	数组下标越界	检查下标是否在 `0..<arr.count` 范围内
`try-with-resources variable not closed`	资源未正确释放	确保资源类的 `close()` 逻辑正确