zig 函数

第四章：函数

4.1 函数定义和调用

基本函数定义

const std = @import("std");

// 基本函数定义
pub fn add(a: i32, b: i32) i32 {
    return a + b;
}

// 无返回值的函数
pub fn printMessage(message: []const u8) void {
    std.debug.print("{s}\n", .{message});
}

pub fn main() void {
    const result = add(5, 3);
    printMessage("结果是: ");
    std.debug.print("{d}\n", .{result});
}

函数文档注释

/// 计算两个数的和
/// 参数:
///   a: 第一个加数
///   b: 第二个加数
/// 返回: 两个数的和
pub fn add(a: i32, b: i32) i32 {
    return a + b;
}

4.2 参数传递

值传递

pub fn increment(x: i32) i32 {
    return x + 1;
}

pub fn main() void {
    const a = 5;
    const b = increment(a);
    // a 仍然是 5，b 是 6
}

指针参数

pub fn incrementPtr(x: *i32) void {
    x.* += 1;
}

pub fn main() void {
    var a: i32 = 5;
    incrementPtr(&a);
    // a 现在是 6
}

切片参数

pub fn sum(numbers: []const i32) i32 {
    var total: i32 = 0;
    for (numbers) |number| {
        total += number;
    }
    return total;
}

pub fn main() void {
    const numbers = [_]i32{ 1, 2, 3, 4, 5 };
    const result = sum(&numbers);
    std.debug.print("总和: {d}\n", .{result});
}

4.3 返回值

多返回值

pub fn divMod(a: i32, b: i32) struct { quotient: i32, remainder: i32 } {
    return .{
        .quotient = @divFloor(a, b),
        .remainder = @mod(a, b),
    };
}

pub fn main() void {
    const result = divMod(10, 3);
    std.debug.print("商: {d}, 余数: {d}\n", .{
        result.quotient,
        result.remainder,
    });
}

可选返回值

pub fn findFirst(numbers: []const i32, target: i32) ?usize {
    for (numbers, 0..) |number, index| {
        if (number == target) return index;
    }
    return null;
}

pub fn main() void {
    const numbers = [_]i32{ 1, 2, 3, 4, 5 };
    if (findFirst(&numbers, 3)) |index| {
        std.debug.print("找到数字在索引: {d}\n", .{index});
    } else {
        std.debug.print("未找到数字\n", .{});
    }
}

4.4 错误处理机制

定义错误集

const MathError = error{
    DivisionByZero,
    Overflow,
};

pub fn divide(a: i32, b: i32) MathError!i32 {
    if (b == 0) return MathError.DivisionByZero;
    if (a == std.math.minInt(i32) and b == -1) {
        return MathError.Overflow;
    }
    return @divFloor(a, b);
}

错误处理

pub fn main() !void {
    // 使用 try
    const result1 = try divide(10, 2);
    std.debug.print("结果1: {d}\n", .{result1});
    
    // 使用 catch
    const result2 = divide(10, 0) catch |err| {
        std.debug.print("错误: {}\n", .{err});
        return;
    };
    
    // 使用 if-else
    if (divide(10, 3)) |result| {
        std.debug.print("结果: {d}\n", .{result});
    } else |err| {
        std.debug.print("错误: {}\n", .{err});
    }
}

4.5 递归函数

pub fn factorial(n: u64) u64 {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

pub fn fibonacci(n: u64) u64 {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

pub fn main() void {
    const fac5 = factorial(5);
    const fib6 = fibonacci(6);
    
    std.debug.print("5的阶乘: {d}\n", .{fac5});
    std.debug.print("第6个斐波那契数: {d}\n", .{fib6});
}

练习：

1. 实现一个函数，接受一个整数数组，返回其最大值和最小值
2. 编写一个递归函数计算数组元素的和
3. 实现一个安全的除法函数，处理除零和溢出错误
4. 创建一个函数，接受可变数量的参数并返回它们的平均值

注意事项：

1. 函数参数默认是不可变的
2. 错误处理是显式的，必须处理所有可能的错误
3. 递归函数要注意终止条件
4. 使用文档注释来说明函数的用途和参数

下一步：

在下一章中，我们将学习复合数据类型，包括数组、切片、结构体和枚举等。