参数类型标注
为什么参数必须标注类型
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>。