参数类型标注 ​

为什么参数必须标注类型 ​

Rust 要求函数的每个参数都必须显式标注类型。这是有意的设计——编译器虽然有强大的类型推断能力,但在函数签名这个"边界"上,强制标注类型让代码的意图更清晰,也让编译器能独立地检查每个函数,不需要分析所有调用者才能确定参数类型。

rust
// 每个参数都必须标注类型
fn add(a: i32, b: i32) -> i32 {
    a + b
}

// 不标注类型会编译错误
// fn add_bad(a, b) -> i32 {  // 编译错误:expected one of `:`, `@`, or `|`
//     a + b
// }

fn main() {
    println!("{}", add(3, 5));
}

基本类型参数 ​

rust
// 整数参数
fn square(n: i64) -> i64 {
    n * n
}

// 浮点数参数
fn circle_area(radius: f64) -> f64 {
    std::f64::consts::PI * radius * radius
}

// 布尔参数
fn greeting(name: &str, formal: bool) -> String {
    if formal {
        format!("尊敬的{},您好!", name)
    } else {
        format!("嗨,{}!", name)
    }
}

// 字符参数
fn is_vowel(ch: char) -> bool {
    matches!(ch, 'a' | 'e' | 'i' | 'o' | 'u' | 'A' | 'E' | 'I' | 'O' | 'U')
}

fn main() {
    println!("5² = {}", square(5));
    println!("半径3的圆面积:{:.2}", circle_area(3.0));
    println!("{}", greeting("张三", true));
    println!("'a' 是元音:{}", is_vowel('a'));
}

引用类型参数 ​

参数可以是引用类型,这样调用者不会失去所有权。

rust
// 不可变引用:借用数据,不能修改
fn print_list(items: &[i32]) {
    for (i, item) in items.iter().enumerate() {
        println!("  [{}] {}", i, item);
    }
}

// 可变引用:借用数据,可以修改
fn double_all(items: &mut Vec<i32>) {
    for item in items.iter_mut() {
        *item *= 2;
    }
}

// 字符串切片引用
fn count_words(text: &str) -> usize {
    text.split_whitespace().count()
}

// String 引用
fn append_suffix(s: &mut String, suffix: &str) {
    s.push_str(suffix);
}

fn main() {
    let data = vec![1, 2, 3, 4, 5];
    print_list(&data);  // 传不可变引用

    let mut data2 = vec![10, 20, 30];
    double_all(&mut data2);  // 传可变引用
    println!("翻倍后:{:?}", data2);

    println!("单词数:{}", count_words("Hello World Rust"));

    let mut name = String::from("hello");
    append_suffix(&mut name, "_world");
    println!("{}", name);
}

所有权参数 ​

当参数类型不是引用时,调用函数会把值的所有权转移进去。

rust
// 获取 String 的所有权
fn consume_string(s: String) {
    println!("消耗了:{}", s);
    // s 在函数结束时被释放
}

// 获取 Vec 的所有权并返回处理结果
fn sort_and_return(mut items: Vec<i32>) -> Vec<i32> {
    items.sort();
    items  // 所有权转移给调用者
}

fn main() {
    let s = String::from("hello");
    consume_string(s);
    // println!("{}", s);  // 编译错误:s 的所有权已经转移

    let data = vec![5, 3, 1, 4, 2];
    let sorted = sort_and_return(data);
    println!("排序后:{:?}", sorted);
    // data 已经不可用了
}

多种参数类型组合 ​

rust
// 混合不同类型的参数
fn create_user_info(
    name: &str,        // 字符串切片引用
    age: u32,          // 无符号整数(Copy 类型,不涉及所有权)
    email: String,     // 拥有所有权的 String
    is_admin: bool,    // 布尔值
) -> String {
    let role = if is_admin { "管理员" } else { "普通用户" };
    format!("{}({}岁,{},{})- {}", name, age, email, role, 
        if age >= 18 { "已成年" } else { "未成年" })
}

// 元组参数
fn distance(p1: (f64, f64), p2: (f64, f64)) -> f64 {
    let dx = p2.0 - p1.0;
    let dy = p2.1 - p1.1;
    (dx * dx + dy * dy).sqrt()
}

// 数组参数(固定长度)
fn sum_three(arr: [i32; 3]) -> i32 {
    arr[0] + arr[1] + arr[2]
}

fn main() {
    let info = create_user_info("张三", 25, String::from("z@test.com"), false);
    println!("{}", info);

    let dist = distance((0.0, 0.0), (3.0, 4.0));
    println!("距离:{}", dist);

    println!("数组之和:{}", sum_three([10, 20, 30]));
}

基本示例 ​

实现一个简单的字符串处理工具集:

rust
// 截取字符串的前 n 个字符
fn take_chars(s: &str, n: usize) -> String {
    s.chars().take(n).collect()
}

// 重复字符串 n 次
fn repeat_str(s: &str, times: usize) -> String {
    s.repeat(times)
}

// 在两个字符串之间添加分隔符
fn join_with(left: &str, right: &str, separator: &str) -> String {
    format!("{}{}{}", left, separator, right)
}

// 统计指定字符出现的次数
fn count_char(text: &str, target: char) -> usize {
    text.chars().filter(|&c| c == target).count()
}

// 将字符串的首字母大写
fn capitalize_first(s: &str) -> String {
    let mut chars = s.chars();
    match chars.next() {
        None => String::new(),
        Some(first) => {
            let upper: String = first.to_uppercase().collect();
            upper + chars.as_str()
        }
    }
}

fn main() {
    println!("{}", take_chars("Hello, World!", 5));
    println!("{}", repeat_str("abc", 3));
    println!("{}", join_with("hello", "world", " - "));
    println!("'l' 出现次数:{}", count_char("hello world", 'l'));
    println!("{}", capitalize_first("rust"));
}

常见问题 ​

问题一:多个参数类型相同时能合并写吗?

不能。每个参数都必须单独标注类型,不能像某些语言那样写 fn foo(a, b: i32)。

rust
// 正确:每个参数单独标注
fn add(a: i32, b: i32) -> i32 { a + b }

// 错误:不能合并
// fn add(a, b: i32) -> i32 { a + b }

问题二:参数用 &str 还是 String?

如果函数只是读取字符串内容,用 &str——它既能接受字面量也能接受 &String。如果函数需要拥有字符串的所有权(比如存到结构体里),用 String。

问题三:参数用 &Vec<T> 还是 &[T]?

优先用 &[T](切片引用)。它比 &Vec<T> 更通用,既能接受 Vec 也能接受数组。

参数类型接受的输入推荐程度
&[T]Vec、数组、切片推荐
&Vec<T>只有 Vec不推荐

问题四:参数太多怎么办?

超过 4-5 个参数时,应该考虑把相关的参数封装成结构体,让函数签名更清晰。

适用场景 ​

  • 只读访问:用不可变引用 &T
  • 修改调用者的数据:用可变引用 &mut T
  • 转移所有权:直接传值 T
  • 字符串参数:用 &str 最通用
  • 集合参数:用切片 &[T] 最通用

注意事项 ​

  • 函数参数必须显式标注类型,不能依赖类型推断
  • 每个参数都要单独标注,不能合并
  • 参数是引用时注意区分 &T(不可变)和 &mut T(可变)
  • 非引用参数会转移所有权(Copy 类型除外)
  • 字符串参数优先用 &str,集合参数优先用 &[T]
  • 参数过多时考虑用结构体封装

总结 ​

Rust 强制要求函数参数显式标注类型,这让函数签名成为一份清晰的"契约"——调用者和实现者都能一目了然地知道需要什么类型的数据。参数类型的选择直接影响所有权:引用类型(&T、&mut T)借用数据,非引用类型转移所有权。函数参数类型的最佳实践是用最通用的类型:字符串用 &str,集合用 &[T],只在需要所有权时才用 String 或 Vec<T>。