推进你的 Rust 学习,熟悉 Rust 程序的变量和常量。

该系列的第一章中,我讲述了为什么 Rust 是一门越来越流行的编程语言。我还展示了如何 在 Rust 中编写 Hello World 程序

让我们继续 Rust 之旅。在本文中,我将向你介绍 Rust 编程语言中的变量和常量。

此外,我还将讲解一个称为“ 遮蔽 shadowing ”的新编程概念。

Rust 变量的独特之处

在编程语言中,变量是指 存储某些数据的内存地址的一个别名

对 Rust 语言来讲也是如此。但是 Rust 有一个独特的“特性”。每个你声明的变量都是 默认 不可变的 immutable 。这意味着一旦给变量赋值,就不能再改变它的值。

这个决定是为了确保默认情况下,你不需要使用 自旋锁 spin lock 互斥锁 mutex 等特殊机制来引入多线程。Rust 会保证 安全的并发。由于所有变量(默认情况下)都是不可变的,因此你不需要担心线程会无意中更改变量值。

这并不是在说 Rust 中的变量就像常量一样,因为它们确实不是常量。变量可以被显式地定义为可变的。这样的变量称为 可变变量

这是在 Rust 中声明变量的语法:

// 默认情况下不可变
// 初始化值是**唯一**的值
let variable_name = value;

// 使用 'mut' 关键字定义可变变量
// 初始化值可以被改变
let mut variable_name = value;

? 尽管你可以改变可变变量的值,但你不能将另一种数据类型的值赋值给它。

这意味着,如果你有一个可变的浮点型变量,你不能在后面将一个字符赋值给它。

Rust 数据类型概观

在上一篇文章中,你可能注意到了我提到 Rust 是一种强类型语言。但是在定义变量时,你不需要指定数据类型,而是使用一个通用的关键字 let

Rust 编译器可以根据赋值给变量的值推断出变量的数据类型。但是如果你仍然希望明确指定数据类型并希望注释类型,那么可以这样做。以下是语法:

let variable_name: data_type = value;

下面是 Rust 编程语言中一些常见的数据类型:

  • 整数类型:分别用于有符号和无符号的 32 位整数的 i32u32
  • 浮点类型:分别用于 32 位和 64 位浮点数的 f32f64
  • 布尔类型bool
  • 字符类型char

我会在下一篇文章中更详细地介绍 Rust 的数据类型。现在,这应该足够了。

? Rust 并不支持隐式类型转换。因此,如果你将值 8 赋给一个浮点型变量,你将会遇到编译时错误。你应该赋的值是 8.8.0

Rust 还强制要求在读取存储在其中的值之前初始化变量。

{ // 该代码块不会被编译
    let a;
    println!("{}", a); // 本行报错
    // 读取一个**未初始化**变量的值是一个编译时错误
}

{ // 该代码块会被编译
    let a;
    a = 128;
    println!("{}", a); // 本行不会报错
    // 变量 'a' 有一个初始值
}

如果你在不初始化的情况下声明一个变量,并在给它赋值之前使用它,Rust 编译器将会抛出一个 编译时错误

虽然错误很烦人,但在这种情况下,Rust 编译器强制你不要犯写代码时常见的错误之一:未初始化的变量。

Rust 编译器的错误信息

来写几个程序,你将

  • 通过执行“正常”的任务来理解 Rust 的设计,这些任务实际上是内存相关问题的主要原因
  • 阅读和理解 Rust 编译器的错误/警告信息

测试变量的不可变性

让我们故意写一个试图修改不可变变量的程序,看看接下来会发生什么。

fn main() {
    let mut a = 172;
    let b = 273;
    println!("a: {a}, b: {b}");

    a = 380;
    b = 420;
    println!("a: {}, b: {}", a, b);
}

直到第 4 行看起来都是一个简单的程序。但是在第 7 行,变量 b —— 一个不可变变量 —— 的值被修改了。

注意打印 Rust 变量值的两种方法。在第 4 行,我将变量括在花括号中,以便打印它们的值。在第 8 行,我保持括号为空,并使用 C 的风格将变量作为参数。这两种方法都是有效的。(除了修改不可变变量的值,这个程序中的所有内容都是正确的。)

来编译一下!如果你按照上一章的步骤做了,你已经知道该怎么做了。

$ rustc main.rs
error[E0384]: cannot assign twice to immutable variable `b`
 --> main.rs:7:5
  |
3 |     let b = 273;
  |         -
  |         |
  |         first assignment to `b`
  |         help: consider making this binding mutable: `mut b`
...
7 |     b = 420;
  |     ^^^^^^^ cannot assign twice to immutable variable

error: aborting due to previous error

For more information about this error, try `rustc --explain E0384`.
? “binding” 一词是指变量名。但这只是一个简单的解释。

这很好的展示了 Rust 强大的错误检查和信息丰富的错误信息。第一行展示了阻止上述代码编译的错误信息:

error[E0384]: cannot assign twice to immutable variable b

这意味着,Rust 编译器注意到我试图给变量 b 重新赋值,但变量 b 是一个不可变变量。所以这就是导致这个错误的原因。

编译器甚至可以识别出错误发生的确切行和列号。

在显示 first assignment to b 的行下面,是提供帮助的行。因为我正在改变不可变变量 b 的值,所以我被告知使用 mut 关键字将变量 b 声明为可变变量。

?️ 自己实现一个修复来更好地理解手头的问题。

使用未初始化的变量

现在,让我们看看当我们尝试读取未初始化变量的值时,Rust 编译器会做什么。

fn main() {
    let a: i32;
    a = 123;
    println!("a: {a}");

    let b: i32;
    println!("b: {b}");
    b = 123;
}

这里,我有两个不可变变量 ab,在声明时都没有初始化。变量 a 在其值被读取之前被赋予了一个值。但是变量 b 的值在被赋予初始值之前被读取了。

来编译一下,看看结果。

$ rustc main.rs
warning: value assigned to `b` is never read
 --> main.rs:8:5
  |
8 |     b = 123;
  |     ^
  |
  = help: maybe it is overwritten before being read?
  = note: `#[warn(unused_assignments)]` on by default

error[E0381]: used binding `b` is possibly-uninitialized
 --> main.rs:7:19
  |
6 |     let b: i32;
  |         - binding declared here but left uninitialized
7 |     println!("b: {b}");
  |                   ^ `b` used here but it is possibly-uninitialized
  |
  = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)

error: aborting due to previous error; 1 warning emitted

For more information about this error, try `rustc --explain E0381`.

这里,Rust 编译器抛出了一个编译时错误和一个警告。警告说变量 b 的值从来没有被读取过。

但是这是荒谬的!变量 b 的值在第 7 行被访问了。但是仔细看;警告是关于第 8 行的。这很令人困惑;让我们暂时跳过这个警告,继续看错误。

这个错误信息说 used binding b is possibly-uninitialized。和之前的例子一样,Rust 编译器指出错误是由于尝试在第 7 行读取变量 b 的值而引起的。读取变量 b 的值是错误的原因是它的值没有初始化。在 Rust 编程语言中,这是非法的。因此编译时错误出现。

?️ 这个错误可以很容易地通过交换第 7 和第 8 行的代码来解决。试一下,看看错误是否消失了。

示例程序:交换数字

现在你已经熟悉了常见的变量相关问题,让我们来看一个交换两个变量值的程序。

fn main() {
    let mut a = 7186932;
    let mut b = 1276561;

    println!("a: {a}, b: {b}");

    // 交换变量值
    let temp = a;
    a = b;
    b = temp;

    println!("a: {}, b: {}", a, b);
}

我在这里声明了两个变量 ab。这两个变量都是可变的,因为我希望在后面改变它们的值。我赋予了一些随机值。最初,我打印了这些变量的值。

然后,在第 8 行,我创建了一个名为 temp 的不可变变量,并将存储在 a 中的值赋给它。之所以这个变量是不可变的,是因为 temp 的值不会改变。

要交换值,我将变量 b 的值赋给变量 a,在下一行,我将 temp 的值(它包含 a 的值)赋给变量 b。现在值已经交换了,我打印了变量 ab 的值。

在编译并执行上面的代码后,我得到了以下输出:

a: 7186932, b: 1276561
a: 1276561, b: 7186932

正如你所见,值已经交换了。完美。

使用未使用的变量

当你声明了一些变量,打算在后面使用它们,但是还没有使用它们,然后编译你的 Rust 代码来检查一些东西时,Rust 编译器会警告你。

原因是显而易见的。不会被使用的变量占用了不必要的初始化时间(CPU 周期)和内存空间。如果不会被使用,为什么要在程序写上它呢?尽管编译器确实会优化这一点。但是它仍然是一个问题,因为它会以多余的代码的形式影响可读性。

但是,有的时候,你可能会面对这样的情况:创建一个变量与否不在你的控制之下。比如说,当一个函数返回多个值,而你只需要其中的一些值时。在这种情况下,你不能要求库维护者根据你的需要调整他们的函数。

所以,在这种情况下,你可以写一个以下划线开头的变量,Rust 编译器将不再显示这样的警告。如果你真的不需要使用存储在该未使用变量中的值,你可以简单地将其命名为 _(下划线),Rust 编译器也会忽略它!

接下来的程序不仅不会生成任何输出,而且也不会生成任何警告和/或错误消息:

fn main() {
    let _unnecessary_var = 0; // 没有警告
    let _ = 0.0; // 完全忽略
}

算术运算

数学就是数学,Rust 并没有在这方面创新。你可以使用在其他编程语言(如 C、C++ 和/或 Java)中使用过的所有算术运算符。

包含可以在 Rust 编程语言中使用的所有运算符和它们的含义的完整列表可以在 这里 找到。

示例程序:一个生锈的温度计

(LCTT 译注:这里的温度计“生锈”了是因为它是使用 Rust(生锈)编写的,原作者在这里玩了一个双关。)

接下来是一个典型的程序,它将华氏度转换为摄氏度,反之亦然。

fn main() {
    let boiling_water_f: f64 = 212.0;
    let frozen_water_c: f64 = 0.0;

    let boiling_water_c = (boiling_water_f - 32.0) * (5.0 / 9.0);
    let frozen_water_f = (frozen_water_c * (9.0 / 5.0)) + 32.0;

    println!(
        "Water starts boiling at {}°C (or {}°F).",
        boiling_water_c, boiling_water_f
    );
    println!(
        "Water starts freezing at {}°C (or {}°F).",
        frozen_water_c, frozen_water_f
    );
}

没什么大不了的……华氏温度转换为摄氏温度,反之亦然。

正如你在这里看到的,由于 Rust 不允许自动类型转换,我不得不在整数 32、9 和 5 后放一个小数点。除此之外,这与你在 C、C++ 和/或 Java 中所做的类似。

作为练习,尝试编写一个程序,找出给定数中有多少位数字。

常量

如果你有一些编程知识,你可能知道这意味着什么。常量是一种特殊类型的变量,它的值永远不会改变它保持不变

在 Rust 编程语言中,使用以下语法声明常量:

const CONSTANT_NAME: data_type = value;

如你所见,声明常量的语法与我们在 Rust 中看到的变量声明非常相似。但是有两个不同之处:

  • 常量的名字需要像 SCREAMING_SNAKE_CASE 这样。所有的大写字母和单词之间用下划线分隔。
  • 常量的数据类型必须被显性定义。

变量与常量的对比

你可能在想,既然变量默认是不可变的,为什么语言还要包含常量呢?

接下来这个表格应该可以帮助你消除疑虑。(如果你好奇并且想更好地理解这些区别,你可以看看我的博客,它详细地展示了这些区别。)

一个展示 Rust 编程语言中变量和常量之间区别的表格

使用常量的示例程序:计算圆的面积

这是一个很直接的关于 Rust 中常量的简单程序。它计算圆的面积和周长。

fn main() {
    const PI: f64 = 3.14;
    let radius: f64 = 50.0;

    let circle_area = PI * (radius * radius);
    let circle_perimeter = 2.0 * PI * radius;

    println!("有一个周长为 {radius} 厘米的圆");
    println!("它的面积是 {} 平方厘米", circle_area);
    println!(
        "以及它的周长是 {} 厘米",
        circle_perimeter
    );
}

如果运行代码,将产生以下输出:

有一个周长为 50 厘米的圆
它的面积是 7850 平方厘米
以及它的周长是 314 厘米

Rust 中的变量遮蔽

如果你是一个 C++ 程序员,你可能已经知道我在说什么了。当程序员声明一个与已经声明的变量同名的新变量时,这就是变量遮蔽。

与 C++ 不同,Rust 允许你在同一作用域中执行变量遮蔽!

? 当程序员遮蔽一个已经存在的变量时,新变量会被分配一个新的内存地址,但是使用与现有变量相同的名称引用。

来看看它在 Rust 中是如何工作的。

fn main() {
    let a = 108;
    println!("a 的地址: {:p}, a 的值 {a}", &a);
    let a = 56;
    println!("a 的地址: {:p}, a 的值: {a} // 遮蔽后", &a);

    let mut b = 82;
    println!("\nb 的地址: {:p}, b 的值: {b}", &b);
    let mut b = 120;
    println!("b的地址: {:p}, b的值: {b} // 遮蔽后", &b);

    let mut c = 18;
    println!("\nc 的地址: {:p}, c的值: {c}", &c);
    c = 29;
    println!("c 的地址: {:p}, c的值: {c} // 遮蔽后", &c);
}

println 语句中花括号内的 :p 与 C 中的 %p 类似。它指定值的格式为内存地址(指针)。

我在这里使用了 3 个变量。变量 a 是不可变的,并且在第 4 行被遮蔽。变量 b 是可变的,并且在第 9 行也被遮蔽。变量 c 是可变的,但是在第 14 行,只有它的值被改变了。它没有被遮蔽。

现在,让我们看看输出。

a 的地址: 0x7ffe954bf614, a 的值 108
a 的地址: 0x7ffe954bf674, a 的值: 56 // 遮蔽后

b 的地址: 0x7ffe954bf6d4, b 的值: 82
b 的地址: 0x7ffe954bf734, b 的值: 120 // 遮蔽后

c 的地址: 0x7ffe954bf734, c 的值: 18
c 的地址: 0x7ffe954bf734, c 的值: 29 // 遮蔽后

来看看输出,你会发现不仅所有三个变量的值都改变了,而且被遮蔽的变量的地址也不同(检查十六进制的最后几个字符)。

变量 ab 的内存地址改变了。这意味着变量的可变性或不可变性并不是遮蔽变量的限制。

总结

本文介绍了 Rust 编程语言中的变量和常量。还介绍了算术运算。

做个总结:

  • Rust 中的变量默认是不可变的,但是可以引入可变性。
  • 程序员需要显式地指定变量的可变性。
  • 常量总是不可变的,无论如何都需要类型注释。
  • 变量遮蔽是指使用与现有变量相同的名称声明一个 变量。

很好!我相信和 Rust 一起的进展不错。在下一章中,我将讨论 Rust 中的数据类型。敬请关注。

与此同时,如果你有任何问题,请告诉我。

(题图:MJ/7c5366b8-f926-487e-9153-0a877145ca5)


via: https://itsfoss.com/rust-variables/

作者:Pratham Patel 选题:lkxed 译者:Cubik 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

添加新评论