Rust 函数
- Rust函数定义:在Rust中,函数使用
fn
关键字定义,包括函数名、参数和函数体。函数可以执行特定任务,并通过参数接收外部值,使其具有更广泛的应用和重用性。 - 函数调用:通过函数名和括号
()
调用函数,可在程序的任何地方执行定义的任务。例如,greet()
函数调用会执行其内部代码。 - 带返回值的函数:Rust函数可以返回值,使用
->
标记返回类型。使用return
关键字或省略return
且无分号的表达式作为返回值。例如,fn add(a: i32, b: i32) -> i32 { a + b }
返回两个数的和。
函数是执行特定任务的可重用代码块。例如,如果我们想创建一个程序来加两个数,那么我们可以创建一个 Rust 函数来实现加法。现在,每当我们需要加两个数时,就可以重用这个函数。
在 Rust 中创建函数有助于将代码分割成更小的块,使代码看起来更整洁、更易于理解。
不仅在 Rust 中,函数也是任何编程语言的核心构建块之一。
在 Rust 中定义函数
在 Rust 中,我们使用 fn
关键字来定义函数。函数的语法如下,
fn function_name(arguments) {
// code
}
让我们来看一个例子。
fn greet() {
// code
}
这里,
fn
- 用于在 Rust 中创建函数的关键字greet()
- 函数名称// code
- 函数体{ }
- 函数体的开始和结束
现在让我们完成 greet()
函数,以打印 "Hello, World!"。
// 定义一个函数
fn greet() {
println!("Hello, World!");
}
fn main() {
}
当我们运行这段代码时,我们不会得到任何输出。这是因为我们只是在定义一个函数。要执行一个函数,我们需要调用它。
在 Rust 中调用函数
我们使用函数名称和括号 ()
来调用一个函数。
// 调用一个函数
greet();
让我们现在完成上面的示例。
// 定义一个函数
fn greet() {
println!("Hello, World!");
}
fn main() {
// 函数调用
greet();
}
输出
Hello, World!
这里,我们创建了一个 greet()
函数,它在屏幕上打印 "Hello, World!"。请注意,我们是从 main()
函数内部调用这个函数的。
Rust 中的 main() 函数
如果你仔细观察,可以看到 main()
的语法与函数类似。
fn main() {
// 函数调用
greet();
}
在 Rust 中,main()
也是一个函数,被称为内置函数,具有特殊的含义。它是每个 Rust 程序的入口点(开始)。
注意: Rust 代码使用小写作为定义函数名称的惯例。带有多个单词的扩展函数名称之间会有下划线。
示例:在 Rust 中添加两个数字的函数
// 一个用于加两个数字的函数
fn add() {
let a = 5;
let b = 10;
let sum = a + b;
println!("a 和 b 的和 = {}", sum);
}
fn main() {
// 函数调用
add();
}
输出
a 和 b 的和 = 15
在上面的示例中,我们创建了一个名为 add()
的函数。该函数加两个数字并打印和。
以下是程序的工作方式,
Rust 中的函数参数
从定义中我们知道,函数应该是可重用的。然而,我们之前示例中的 add()
函数只能用于计算 5 和 10 的和。
// 一个用于加两个数字的函数
fn add() {
let a = 5;
let b = 10;
let sum = a + b;
println!("a 和 b 的和 = {}", sum);
}
这个函数不够动态,无法被重用。
为了解决这个问题,并使我们的函数更具动态性,我们可以创建接受外部值的函数。这些外部值被称为函数参数。
以下是我们如何创建带参数的函数。
// 带参数的函数
fn add(a: i32, b:
i32) {
let sum = a + b;
println!("a 和 b 的和 = {}", sum);
}
这里,
a
和b
是函数参数i32
是参数的数据类型
要调用这个函数,我们在函数调用时需要提供一些值。
add(2, 11);
这里,2 和 11 被称为传递给 add
函数的函数参数。
示例:带参数的函数
// 定义一个带有两个参数的 add 函数
fn add(a: i32, b: i32) {
let sum = a + b;
println!("a 和 b 的和 = {}", sum);
}
fn main() {
// 使用参数调用 add 函数
add(2, 11);
}
输出
a 和 b 的和 = 13
以下是程序的工作方式,
调用函数时,参数会被分配给函数参数。
- 2 被分配给
a
- 11 被分配给
b
结果,我们在屏幕上看到 2 和 11 的和等于 13。
在 Rust 中带返回值的函数
在最后一个示例中,我们计算了两个数字的和,并在函数内部打印了结果。然而,我们也可以从函数中返回结果,并在我们的程序中的任何地方使用它。
以下是我们如何在 Rust 中创建一个返回值的函数。
// 定义一个带有两个参数和返回类型的 add 函数
fn add(a: i32, b: i32) -> i32 {
let sum = a + b;
// 从函数中返回一个值
return sum;
}
这里,-> i32
出现在开大括号 {
前,表示函数的返回类型。在这种情况下,函数将返回一个 i32
值。
我们然后使用 return
关键字从函数中返回 sum
变量。
函数返回的值需要存储在某个地方,因为函数将值返回到它被调用的地方。
// 将返回的值存储在一个变量中
let sum = add(3, 5);
示例:带返回值的函数
// 定义一个带有两个参数和返回类型的 add 函数
fn add(a: i32, b: i32) -> i32 {
let sum = a + b;
// 从函数中返回一个值
return sum;
}
fn main() {
// 函数调用
let sum = add(3, 5);
println!("a 和 b 的和 = {}", sum);
}
输出
a 和 b 的和 = 8
以下是程序的工作方式,
在上面的示例中,当我们到达 add 函数中的 return
语句时,它返回 sum
变量。返回的值存储在 main()
内的 sum
变量中。
常见问题
如何使用 Rust 表达式从函数中返回一个值?
以表达式结尾的函数将返回表达式的值。这意味着我们不必使用 return
关键字就可以从函数中返回一个值。例如,
fn add(a: i32, b: i32) -> i32 {
a + b
}
fn main() {
let sum = add(1, 2);
println!("和 = {}", sum);
}
输出
和 = 3
注意: 请注意函数体中的 a + b
没有以分号结束。表达式不包括结束分号,但语句包括。
我们如何从 Rust 函数中返回多个值?
我们可以使用元组从函数中返回多个值。例如,
fn addsub(a: i32, b: i32) -> (i32, i32) {
return (a + b, a - b);
}
fn main() {
let (sum, diff) = addsub(4, 1);
println!("和 = {}, 差 = {}", sum, diff);
}
输出
和 = 5, 差 = 3
这里,函数的返回类型是一个元组 (i32, i32)
。
如何在 Rust 中通过引用传递?
我们可以通过引用传递来传递变量的指针,而不是实际的变量。例如,
fn main() {
let word = String::from("hello");
// 传递 word 变量的引用
let len = calculate_length(&word);
println!("'{}' 的长度是 {}。", word, len);
}
fn calculate_length(s: &String) -> usize {
return s.len();
}
输出
'hello' 的长度是 5。
这里,我们用 &word
将 word
变量作为引用传递给 calculate_length()
函数。
Rust 函数的优势是什么?
函数是 Rust 编程语言的构建块,带来了许多优势。其中一些是:
- 函数将我们的代码划分为更小、可重用的块。
- 函数有助于使我们的程序更易于阅读和调试。
- 函数使我们的程序模块化,更易于更改,并有助于减少代码重复。