@ -4,13 +4,12 @@
计算机和数值关联在一起的时间，远比我们想象的要长，因此数值类型可以说是有计算机以来就有的类型，下面内容将深入讨论 Rust 的数值类型以及相关的运算符。
## 整数和浮点数
Rust 使用一个相对传统的语法来创建整数（`1`， ， ， ，
> 不仅仅是数值类型， `+` 运算符， ，
## ## 整数类型
## 整数类型
**整数**是没有小数部分的数字。之前使用过的 `i32` 类型，表示有符号的 32 位整数（ `i` 是英文单词 _integer_ 的首字母，与之相反的是 `u` ，代表无符号 `unsigned` 类型）。下表显示了 Rust 中的内置的整数类型：
@ -42,91 +41,36 @@ Rust 使用一个相对传统的语法来创建整数（`1`， ，
这么多类型，有没有一个简单的使用准则？答案是肯定的， Rust 整形默认使用 `i32` ，例如 `let i = 1` ，那 `i` 就是 `i32` 类型，因此你可以首选它，同时该类型也往往是性能最好的。`isize` 和 `usize` 的主要应用场景是用作集合的索引。
> ##### 整型溢出
>
> 比方说有一个 `u8` ，它可以存放从 0 到 255 的值。那么当你将其修改为范围之外的值，比如 256， ， _panic_ (崩溃,Rust 使用这个术语来表明程序因错误而退出)。
>
> 在当使用 `--release` 参数进行 release 模式构建时， ** 不**检测溢出。相反， ， （ ’ ） ， `u8` 的情况下， ， ， _panic_ ，但是该变量的值可能不是你期望的值。依赖这种默认行为的代码都应该被认为是错误的代码。
>
> 要显式处理可能的溢出，可以使用标准库针对原始数字类型提供的这些方法：
>
> - 使用 `wrapping_*` 方法在所有模式下都按照补码循环溢出规则处理，例如 `wrapping_add`
> - 如果使用 `checked_*` 方法时发生溢出，则返回 `None` 值
> - 使用 `overflowing_*` 方法返回该值和一个指示是否存在溢出的布尔值
> - 使用 `saturating_*` 方法使值达到最小值或最大值
#### 浮点类型
**浮点类型数字** 是带有小数点的数字，在 Rust 中浮点类型数字也有两种基本类型： `f32` 和 `f64` ，分别为 32 位和 64 位大小。默认浮点类型是 `f64` ，在现代的 CPU 中它的速度与 `f32` 几乎相同，但精度更高。
下面是一个演示浮点数的示例：
#### 整型溢出
```rust
fn main() {
let x = 2.0; // f64
let y: f32 = 3.0; // f32
}
```
浮点数根据 `IEEE-754` 标准实现。`f32` 类型是单精度浮点型，`f64` 为双精度。
#### 数字运算
Rust 支持所有数字类型的基本数学运算：加法、减法、乘法、除法和取模运算。下面代码各使用一条 `let` 语句来说明相应运算的用法：
```rust
fn main() {
// 加法
let sum = 5 + 10;
假设有一个 `u8` ，它可以存放从 0 到 255 的值。那么当你将其修改为范围之外的值，比如 256， ， _panic_ (崩溃,Rust 使用这个术语来表明程序因错误而退出)。
// 减法
let difference = 95.5 - 4.3;
在当使用 `--release` 参数进行 release 模式构建时， ** 不**检测溢出。相反， ， （ ’ ） ， `u8` 的情况下， ， ， _panic_ ，但是该变量的值可能不是你期望的值。依赖这种默认行为的代码都应该被认为是错误的代码。
// 乘法
let product = 4 * 30;
要显式处理可能的溢出，可以使用标准库针对原始数字类型提供的这些方法：
// 除法
let quotient = 56.7 / 32.2;
- 使用 `wrapping_*` 方法在所有模式下都按照补码循环溢出规则处理，例如 `wrapping_add`
- 如果使用 `checked_*` 方法时发生溢出，则返回 `None` 值
- 使用 `overflowing_*` 方法返回该值和一个指示是否存在溢出的布尔值
- 使用 `saturating_*` 方法使值达到最小值或最大值
// 求余
let remainder = 43 % 5;
}
```
## 浮点类型
这些语句中的每个表达式都使用了数学运算符，并且计算结果为一个值，然后绑定到一个变量上。[附录 B](https://course.rs/appendix/operators.html#运算符) 中给出了 Rust 提供的所有运算符的列表 。
**浮点类型数字** 是带有小数点的数字，在 Rust 中浮点类型数字也有两种基本类型： `f32` 和 `f64` ，分别为 32 位和 64 位大小。默认浮点类型是 `f64` ，在现代的 CPU 中它的速度与 `f32` 几乎相同，但精度更高。
再来看一个综合性 的示例：
下面是一个演示浮点数的示例：
```rust
fn main() {
// 编译器会进行自动推导，
let twenty = 20;
// 类型标注
let twenty_one: i32 = 21;
// 通过类型后缀的方式进行类型标注：
let twenty_two = 22i32;
// 只有同样类型，才能运算
let addition = twenty + twenty_one + twenty_two;
println!("{} + {} + {} = {}", twenty, twenty_one, twenty_two, addition);
// 对于较长的数字， ，
let one_million: i64 = 1_000_000;
println!("{}", one_million.pow(2));
// 定义一个f32数组，
let forty_twos = [
42.0,
42f32,
42.0_f32,
];
let x = 2.0; // f64
// 打印数组中第一个值，
println!("{:.2}", forty_twos[0]);
let y: f32 = 3.0; // f32
}
```
浮点数根据 `IEEE-754` 标准实现。`f32` 类型是单精度浮点型，`f64` 为双精度。
#### 浮点数陷阱
浮点数由于底层格式的特殊性，导致了如果在使用浮点数时不够谨慎，就可能造成危险，有两个原因：
@ -224,6 +168,106 @@ fn main() {
}
```
## 数字运算
Rust 支持所有数字类型的基本数学运算：加法、减法、乘法、除法和取模运算。下面代码各使用一条 `let` 语句来说明相应运算的用法：
```rust
fn main() {
// 加法
let sum = 5 + 10;
// 减法
let difference = 95.5 - 4.3;
// 乘法
let product = 4 * 30;
// 除法
let quotient = 56.7 / 32.2;
// 求余
let remainder = 43 % 5;
}
```
这些语句中的每个表达式都使用了数学运算符，并且计算结果为一个值，然后绑定到一个变量上。[附录 B](https://course.rs/appendix/operators.html#运算符) 中给出了 Rust 提供的所有运算符的列表。
再来看一个综合性的示例：
```rust
fn main() {
// 编译器会进行自动推导，
let twenty = 20;
// 类型标注
let twenty_one: i32 = 21;
// 通过类型后缀的方式进行类型标注：
let twenty_two = 22i32;
// 只有同样类型，才能运算
let addition = twenty + twenty_one + twenty_two;
println!("{} + {} + {} = {}", twenty, twenty_one, twenty_two, addition);
// 对于较长的数字， ，
let one_million: i64 = 1_000_000;
println!("{}", one_million.pow(2));
// 定义一个f32数组，
let forty_twos = [
42.0,
42f32,
42.0_f32,
];
// 打印数组中第一个值，
println!("{:.2}", forty_twos[0]);
}
```
## 位运算
Rust的运算基本上和其他语言一样
| 运算符 | 说明 |
| ------- | -------------------------------------- |
| & 位与 | 相同位置均为1时则为1，
| \| 位或 | 相同位置只要有1时则为1，
| ^ 异或 | 相同位置不相同则为1，
| ! 位非 | 把位中的0和1相互取反， ，
| < < 左移 | 所有位向左移动指定位数，右位补零 |
| >> 右移 | 所有位向右移动指定位数，左位补零 |
```rust
fn main() {
// 二进制为00000010
let a:i32 = 2;
// 二进制为00000011
let b:i32 = 3;
println!("(a & b) value is {}", a & b);
println!("(a | b) value is {}", a | b);
println!("(a ^ b) value is {}", a ^ b);
println!("(!b) value is {} ", !b);
println!("(a < < b ) value is { } " , a < < b ) ;
println!("(a >> b) value is {}", a >> b);
let mut a = a;
// 注意这些计算符除了!之外都可以加上=进行赋值 (因为!=要用来判断不等于)
a < < = b;
println!("(a < < b ) value is { } " , a ) ;
}
```
## 序列(Range)
Rust 提供了一个非常简洁的方式，用来生成连续的数值，例如 `1..5` ，生成从 1 到 4 的连续数字，不包含 5 ； ， ， ：
Rustln
3 years ago
committed by
GitHub