返回值类型标注
什么是返回值类型标注
Rust 函数的返回值类型用 -> 加类型来标注,放在参数列表的右括号之后、函数体的左花括号之前。如果函数不标注返回类型,默认返回单元类型 ()。
rust
// 有返回值:用 -> 标注类型
fn add(a: i32, b: i32) -> i32 {
a + b
}
// 没有返回值标注,默认返回 ()
fn say_hello() {
println!("你好");
// 隐式返回 ()
}
// 显式标注返回 ()(和不标注效果一样,但不常见)
fn do_nothing() -> () {
// 什么都不做
}
fn main() {
let sum = add(3, 4);
println!("和:{}", sum);
say_hello();
do_nothing();
}常见的返回类型
rust
// 返回基本类型
fn get_pi() -> f64 {
std::f64::consts::PI
}
// 返回布尔值
fn is_even(n: i32) -> bool {
n % 2 == 0
}
// 返回 String
fn build_greeting(name: &str) -> String {
format!("你好,{}!", name)
}
// 返回引用(需要生命周期,这里用 'static)
fn default_name() -> &'static str {
"未命名"
}
// 返回元组
fn min_max(data: &[i32]) -> (i32, i32) {
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; }
}
(min, max)
}
// 返回 Vec
fn generate_range(start: i32, end: i32) -> Vec<i32> {
(start..=end).collect()
}
fn main() {
println!("PI = {:.6}", get_pi());
println!("4 是偶数:{}", is_even(4));
println!("{}", build_greeting("Rust"));
println!("默认名:{}", default_name());
let (min, max) = min_max(&[5, 2, 8, 1, 9]);
println!("最小:{},最大:{}", min, max);
println!("范围:{:?}", generate_range(1, 5));
}返回 Option 和 Result
这是 Rust 中最常见的返回类型模式——用 Option 表示可能没有值,用 Result 表示可能失败。
rust
// 返回 Option<T>:可能没有值
fn find_item(items: &[&str], target: &str) -> Option<usize> {
for (i, &item) in items.iter().enumerate() {
if item == target {
return Some(i);
}
}
None
}
// 返回 Result<T, E>:可能失败
fn parse_port(s: &str) -> Result<u16, String> {
match s.parse::<u16>() {
Ok(port) if port > 0 => Ok(port),
Ok(_) => Err(String::from("端口号不能为 0")),
Err(e) => Err(format!("解析失败:{}", e)),
}
}
// 返回 Result 搭配 ? 操作符
fn read_config(input: &str) -> Result<(String, u16), String> {
let parts: Vec<&str> = input.split(':').collect();
if parts.len() != 2 {
return Err(String::from("格式错误,应为 host:port"));
}
let host = parts[0].to_string();
let port = parse_port(parts[1])?; // ? 自动传播错误
Ok((host, port))
}
fn main() {
let fruits = ["苹果", "香蕉", "橙子"];
println!("查找香蕉:{:?}", find_item(&fruits, "香蕉"));
println!("查找葡萄:{:?}", find_item(&fruits, "葡萄"));
println!("解析端口 8080:{:?}", parse_port("8080"));
println!("解析端口 abc:{:?}", parse_port("abc"));
println!("解析配置:{:?}", read_config("localhost:3000"));
println!("解析配置:{:?}", read_config("bad"));
}返回引用类型
函数返回引用时,编译器需要知道引用的生命周期。返回引用通常来自输入参数。
rust
// 返回输入切片中的一部分(生命周期和输入绑定)
fn first_word(s: &str) -> &str {
match s.find(' ') {
Some(pos) => &s[..pos],
None => s,
}
}
// 返回两个引用中较长的那个
fn longer<'a>(s1: &'a str, s2: &'a str) -> &'a str {
if s1.len() >= s2.len() { s1 } else { s2 }
}
// 返回 Vec 中的元素引用
fn get_last(items: &[i32]) -> Option<&i32> {
items.last()
}
fn main() {
let sentence = "Hello World Rust";
println!("第一个单词:{}", first_word(sentence));
let s1 = "short";
let s2 = "longer string";
println!("较长的:{}", longer(s1, s2));
let nums = vec![10, 20, 30];
println!("最后一个:{:?}", get_last(&nums));
}返回 impl Trait
当返回类型比较复杂(比如闭包、迭代器适配器)时,可以用 impl Trait 来简化。
rust
// 返回一个迭代器(具体类型很长,用 impl Iterator 简化)
fn even_numbers(limit: i32) -> impl Iterator<Item = i32> {
(0..limit).filter(|x| x % 2 == 0)
}
// 返回一个实现了 Display 的类型
fn make_greeting(name: &str) -> impl std::fmt::Display {
format!("你好,{}!", name)
}
fn main() {
print!("偶数:");
for n in even_numbers(10) {
print!("{} ", n);
}
println!();
println!("{}", make_greeting("Rust"));
}基本示例
rust
struct Statistics {
count: usize,
sum: f64,
mean: f64,
min: f64,
max: f64,
}
// 返回自定义结构体
fn compute_stats(data: &[f64]) -> Option<Statistics> {
if data.is_empty() {
return None;
}
let count = data.len();
let sum: f64 = data.iter().sum();
let mean = sum / count as f64;
let min = data.iter().cloned().reduce(f64::min).unwrap();
let max = data.iter().cloned().reduce(f64::max).unwrap();
Some(Statistics { count, sum, mean, min, max })
}
// 返回格式化字符串
fn format_stats(stats: &Statistics) -> String {
format!(
"数量={}, 总和={:.2}, 平均={:.2}, 最小={:.2}, 最大={:.2}",
stats.count, stats.sum, stats.mean, stats.min, stats.max
)
}
fn main() {
let data = vec![23.5, 18.0, 31.2, 27.8, 15.4, 29.1];
match compute_stats(&data) {
Some(stats) => println!("统计:{}", format_stats(&stats)),
None => println!("没有数据"),
}
// 空数据
match compute_stats(&[]) {
Some(_) => println!("有数据"),
None => println!("空数据集"),
}
}常见问题
问题一:函数能返回多个值吗?
Rust 没有"多返回值"的语法,但可以用元组返回多个值,调用者用解构来接收。
rust
fn divide(a: f64, b: f64) -> (f64, f64) {
let quotient = (a / b).floor();
let remainder = a % b;
(quotient, remainder)
}
fn main() {
let (q, r) = divide(17.0, 5.0);
println!("商:{},余数:{}", q, r);
}问题二:返回类型写错了会怎样?
编译器会在函数体的最后一个表达式处报类型不匹配错误,同时指出声明的返回类型和实际的返回类型分别是什么。
问题三:什么时候用 Option,什么时候用 Result?
| 场景 | 返回类型 | 理由 |
|---|---|---|
| 查找可能找不到 | Option<T> | 失败原因只有一种(不存在) |
| 操作可能失败 | Result<T, E> | 调用者需要知道失败原因 |
| 一定能成功 | T | 不需要包装 |
问题四:impl Trait 和泛型有什么区别?
impl Trait 作为返回值时,函数只能返回一种具体类型(编译器推断出来的)。泛型让调用者选择类型,impl Trait 让实现者决定类型。
适用场景
T:函数一定会返回一个值Option<T>:函数可能没有值返回Result<T, E>:函数可能失败,需要传达错误信息(T1, T2):函数需要返回多个值impl Trait:返回类型很复杂,不想暴露具体类型&T:返回输入数据的引用,不复制
注意事项
- 不标注返回类型时默认返回
() ->和类型之间可以有空格也可以没有- 函数体最后一行表达式不加分号才是返回值
- 返回引用时需要注意生命周期
- 所有
return语句和尾部表达式的类型必须一致 impl Trait返回值只能返回一种具体类型- 返回类型为
!表示函数永不返回
总结
返回值类型标注用 -> 类型 语法放在参数列表之后。不标注时默认返回 ()。Rust 提供了丰富的返回类型选择:基本类型、Option<T>(可能无值)、Result<T, E>(可能失败)、元组(多个值)、impl Trait(隐藏具体类型)和引用类型(零拷贝返回)。函数体的最后一行表达式(不加分号)就是返回值,多个返回点(return 和尾部表达式)的类型必须一致。选择合适的返回类型是写好 Rust 函数的关键。