返回值类型标注 ​

什么是返回值类型标注 ​

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 函数的关键。