多元组返回 ​

什么是多元组返回 ​

Rust 没有像 Go 或 Python 那样的"多返回值"语法,但可以用元组来实现同样的效果。函数的返回类型声明为元组类型 (T1, T2, ...),调用者用解构来接收各个值。

rust
// 返回两个值:商和余数
fn div_rem(a: i32, b: i32) -> (i32, i32) {
    (a / b, a % b)  // 返回一个元组
}

fn main() {
    // 解构接收
    let (quotient, remainder) = div_rem(17, 5);
    println!("17 / 5 = {} 余 {}", quotient, remainder);

    // 也可以整体接收
    let result = div_rem(23, 7);
    println!("23 / 7 = {} 余 {}", result.0, result.1);
}

常见的多元组返回场景 ​

rust
// 返回最小值和最大值
fn min_max(data: &[f64]) -> Option<(f64, f64)> {
    if data.is_empty() {
        return None;
    }
    let mut min = data[0];
    let mut max = data[0];
    for &val in &data[1..] {
        if val < min { min = val; }
        if val > max { max = val; }
    }
    Some((min, max))
}

// 分割字符串为两部分
fn split_at_char(s: &str, ch: char) -> (&str, &str) {
    match s.find(ch) {
        Some(pos) => (&s[..pos], &s[pos + ch.len_utf8()..]),
        None => (s, ""),
    }
}

// 返回统计信息
fn statistics(data: &[f64]) -> (f64, f64, usize) {
    let count = data.len();
    let sum: f64 = data.iter().sum();
    let mean = if count > 0 { sum / count as f64 } else { 0.0 };
    (sum, mean, count)
}

fn main() {
    let data = vec![3.5, 1.2, 7.8, 4.6, 2.1];

    if let Some((min, max)) = min_max(&data) {
        println!("最小:{:.1},最大:{:.1}", min, max);
    }

    let (left, right) = split_at_char("key=value", '=');
    println!("键:{},值:{}", left, right);

    let (sum, mean, count) = statistics(&data);
    println!("总和:{:.1},平均:{:.1},数量:{}", sum, mean, count);
}

解构方式 ​

rust
fn get_user() -> (String, u32, bool) {
    (String::from("张三"), 28, true)
}

fn main() {
    // 完全解构
    let (name, age, active) = get_user();
    println!("{}, {}岁, 活跃:{}", name, age, active);

    // 忽略部分值
    let (name, _, _) = get_user();
    println!("只要名字:{}", name);

    // 用 .. 忽略剩余
    let (name, ..) = get_user();
    println!("只要名字:{}", name);

    // 索引访问(不解构)
    let user = get_user();
    println!("年龄:{}", user.1);
}

元组返回 vs 结构体返回 ​

当返回值超过 2-3 个,或者各值的含义不直观时,应该考虑用结构体代替元组。

rust
// 元组返回:值少且含义明显时可以
fn divide(a: f64, b: f64) -> (f64, f64) {
    (a / b, a % b)  // 商和余数,含义清楚
}

// 结构体返回:值多或含义不明显时推荐
struct UserProfile {
    name: String,
    age: u32,
    email: String,
    is_admin: bool,
}

fn create_profile(name: &str, age: u32, email: &str) -> UserProfile {
    UserProfile {
        name: name.to_string(),
        age,
        email: email.to_string(),
        is_admin: false,
    }
}

fn main() {
    let (q, r) = divide(17.0, 5.0);
    println!("商:{:.1},余:{:.1}", q, r);

    let profile = create_profile("张三", 28, "z@test.com");
    println!("{},{}岁", profile.name, profile.age);
}
方式优点缺点适用场景
元组简洁,不需要定义类型各位置含义不明确2-3 个值,含义明显
结构体字段有名字,含义清晰需要额外定义类型多个值,或含义不直观

基本示例 ​

解析简单的日期字符串:

rust
// 解析 "YYYY-MM-DD" 格式,返回年月日
fn parse_date(s: &str) -> Result<(u32, u32, u32), String> {
    let parts: Vec<&str> = s.split('-').collect();
    if parts.len() != 3 {
        return Err(format!("格式错误:'{}',应为 YYYY-MM-DD", s));
    }

    let year = parts[0].parse::<u32>()
        .map_err(|_| format!("年份无效:'{}'", parts[0]))?;
    let month = parts[1].parse::<u32>()
        .map_err(|_| format!("月份无效:'{}'", parts[1]))?;
    let day = parts[2].parse::<u32>()
        .map_err(|_| format!("日期无效:'{}'", parts[2]))?;

    if month < 1 || month > 12 {
        return Err(format!("月份超出范围:{}", month));
    }
    if day < 1 || day > 31 {
        return Err(format!("日期超出范围:{}", day));
    }

    Ok((year, month, day))
}

// 计算两点之间的距离和角度
fn point_info(x1: f64, y1: f64, x2: f64, y2: f64) -> (f64, f64) {
    let dx = x2 - x1;
    let dy = y2 - y1;
    let distance = (dx * dx + dy * dy).sqrt();
    let angle = dy.atan2(dx).to_degrees();
    (distance, angle)
}

fn main() {
    // 日期解析
    let dates = ["2026-03-26", "2026-13-01", "abc-01-01", "2026-1-1"];
    for date_str in &dates {
        match parse_date(date_str) {
            Ok((y, m, d)) => println!("{} -> {}年{}月{}日", date_str, y, m, d),
            Err(e) => println!("{} -> 错误:{}", date_str, e),
        }
    }

    println!();

    // 两点信息
    let (dist, angle) = point_info(0.0, 0.0, 3.0, 4.0);
    println!("距离:{:.2},角度:{:.1}°", dist, angle);
}

常见问题 ​

问题一:元组返回最多能有多少个元素?

语法上没有硬性限制,但标准库为最多 12 个元素的元组实现了 Debug、Clone 等 trait。实际使用中超过 3 个值就应该考虑用结构体。

问题二:元组返回和 out 参数(可变引用)哪个好?

Rust 推荐用元组返回值,而不是通过可变引用参数来"输出"结果。元组返回更清晰,不需要调用者先创建变量。

问题三:可以返回包含引用的元组吗?

可以,但需要注意生命周期。返回的引用必须指向输入参数的数据,不能指向函数内部的局部变量。

rust
// 返回两个引用:生命周期和输入绑定
fn first_last(s: &str) -> (char, char) {
    let first = s.chars().next().unwrap();
    let last = s.chars().last().unwrap();
    (first, last)  // char 是 Copy 的,没有引用问题
}

fn main() {
    let (f, l) = first_last("Rust");
    println!("首:{},尾:{}", f, l);
}

适用场景 ​

  • 商和余数:数学运算返回两个相关值
  • 最小值和最大值:一次遍历同时求出
  • 解析结果:从字符串中提取多个字段
  • 坐标和距离:几何计算返回多个结果
  • 成功/失败 + 附加信息:Result<(T1, T2), E>

注意事项 ​

  • 元组元素超过 3 个时考虑改用结构体
  • 解构时用 _ 或 .. 忽略不需要的值
  • 元组字段没有名字(只有 .0、.1),多了容易搞混
  • 返回 Option<(T1, T2)> 可以同时表示"可能没有值"和"多个返回值"
  • 函数签名中的元组类型也算类型标注的一部分

总结 ​

多元组返回是 Rust 中实现"多返回值"的标准方式。函数返回类型声明为元组 (T1, T2, ...),调用者用解构语法接收各个值。元组适合返回 2-3 个含义明显的值(如商和余数、最小和最大值),超过这个数量或者含义不直观时应该用命名字段的结构体代替。元组返回比通过可变引用参数"输出"结果更符合 Rust 的惯用风格。