多元组返回
什么是多元组返回
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 的惯用风格。