Rust 的基本类型
-
数值类型: 有符号整数 (i8, i16, i32, i64, isize)、 无符号整数 (u8, u16, u32, u64, usize) 、浮点数 (f32, f64)、以及有理数、复数
有无符号 + 类型
i 有符号 i8 的长度 = -128 ～ 127
u 无符号 u8 0 ～ 255
此外，isize 和 usize 类型取决于程序运行的计算机 CPU 类型： 若 CPU 是 32 位的，则这两个类型是 32 位的，同理，若 CPU 是 64 位，那么它们则是 64 位。
Rust 整型默认使用 i32，例如 let i = 1，那 i 就是 i32 类型，因此你可以首选它，同时该类型也往往是性能最好的。isize 和 usize 的主要应用场景是用作集合的索引 -
字符串：字符串字面量和字符串切片 &str
-
布尔类型： true和false
-
字符类型: 表示单个 Unicode 字符，存储为 4 个字节
-
单元类型: 即 () ，其唯一的值也是 ()
整型溢出问题：
假设有一个 u8 ，它可以存放从 0 到 255 的值。那么当你将其修改为范围之外的值，比如 256，则会发生 整型溢出 。关于这一行为 Rust 有一些有趣的规则：当在 debug 模式编译时，Rust 会检查整型溢出，若存在这些问题，则使程序在编译时 panic (崩溃,Rust 使用这个术语来表明程序因错误而退出)。
在当使用 --release 参数进行 release 模式构建时，Rust 不检测溢出。相反，当检测到整型溢出时，Rust 会按照补码循环溢出（ two’s complement wrapping ）的规则处理。简而言之，大于该类型最大值的数值会被补码转换成该类型能够支持的对应数字的最小值。比如在 u8 的情况下，256 变成 0，257 变成 1，依此类推,程序不会 panic，但是该变量的值可能不是你期望的值。依赖这种默认行为的代码都应该被认为是错误的代码。
要显式处理可能的溢出，可以使用标准库针对原始数字类型提供的这些方法：
- 使用
wrapping_*方法在所有模式下都按照补码循环溢出规则处理，例如wrapping_add - 如果使用
checked_*方法时发生溢出，则返回None值 - 使用
overflowing_*方法返回该值和一个指示是否存在溢出的布尔值 - 使用
saturating_*方法使值达到最小值或最大值.
浮点类型数字 是带有小数点的数字，在 Rust 中浮点类型数字也有两种基本类型： f32 和 f64，分别为 32 位和 64 位大小。默认浮点类型是 f64，在现代的 CPU 中它的速度与 f32 几乎相同，但精度更高。
fn float_value() {
let x = 2.0; // f64
let y : f32 = 3.0; //f32
}
浮点数陷阱
浮点数由于底层格式的特殊性，导致了如果在使用浮点数时不够谨慎，就可能造成危险，有两个原因：
-
浮点数往往是想要数字的近似表达浮点数类型是基于二进制实现的，但是我们想要计算的数字往往是基于十进制，例如
0.1在二进制上并不存在精确的表达形式，但是在十进制上就存在。这种不匹配性导致一定的歧义性，更多的，虽然浮点数能代表真实的数值，但是由于底层格式问题，它往往受限于定长的浮点数精度，如果你想要表达完全精准的真实数字，只有使用无限精度的浮点数才行 -
浮点数在某些特性上是反直觉的例如大家都会觉得浮点数可以进行比较，对吧？是的，它们确实可以使用
>，>=等进行比较，但是在某些场景下，这种直觉上的比较特性反而会害了你。因为f32，f64上的比较运算实现的是std::cmp::PartialEq特征(类似其他语言的接口)，但是并没有实现std::cmp::Eq特征，但是后者在其它数值类型上都有定义.Rust 的
HashMap数据结构，是一个 KV 类型的 Hash Map 实现，它对于K没有特定类型的限制，但是要求能用作K的类型必须实现了std::cmp::Eq特征，因此这意味着你无法使用浮点数作为HashMap的Key，来存储键值对，但是作为对比，Rust 的整数类型、字符串类型、布尔类型都实现了该特征，因此可以作为HashMap的Key.
同Java一样，在使用浮点数进行计算和比较时，会有误差问题，0.1 + 0.2并不完全=0.3,它们可能在小数点 N 位后存在误差,在rust中运行下面代码会产生panic错误
fn main {
assert!(0.1 + 0.2 == 0.3);
}
如果要在rust中使用浮点数进行比较计算的话可以参考下面的使用方法：
fnmain() {
let a: f64 = 0.1 + 0.2;
let b: f64 = 0.3;
letepsilon: f64 = 1e-10; // 设置一个非常小的误差范围
if (a - b).abs() < epsilon {
println!("a is approximately equal to b");
} else {
println!("a is not equal to b");
}
}
NaN
对于数学上未定义的结果，例如对负数取平方根 -42.1.sqrt() ，会产生一个特殊的结果：Rust 的浮点数类型使用 NaN (not a number)来处理这些情况
下面的代码会崩溃
fn main() {
let x = (-42.0_f32).sqrt();
assert_eq!(x, x);
}
数字运算
Rust 支持所有数字类型的基本数学运算：加法、减法、乘法、除法和取模运算。下面代码各使用一条 let 语句来说明相应运算的用法：
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;
}
一个更加完整的示例：
fn main() {
// 编译器会进行自动推导，给予twenty i32的类型
let twenty = 20;
// 类型标注
let twenty_one: i32 = 21;
// 通过类型后缀的方式进行类型标注：22是i32类型
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数组，其中42.0会自动被推导为f32类型
let forty_twos = [
42.0,
42f32,
42.0_f32,
];
// 打印数组中第一个值，并控制小数位为2位
println!("{:.2}", forty_twos[0]);
}
位运算
rust的位运算与其他语言使用方式是一致的
| 算符 | 说明 |
|---|---|
| & 位与 | 相同位置均为1时则为1，否则为0 |
| ｜位或 | 相同位置只要有1时则为1，否则为0 |
| ^ 异或 | 相同位置不相同则为1，相同则为0 |
| ! 位非 | 把位中的0和1相互取反，即0置为1，1置为0 |
| << 左移 | 所有位向左移动指定位数，右位补0 |
| >> 右移 | 所有位向右移动指定位数，带符号移动（正数补0，负数补1） |
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);
letmut a = a;
// 注意这些计算符除了!之外都可以加上=进行赋值 (因为!=要用来判断不等于)
a <<= b;
println!("(a << b) value is {}", a);
}
序列(Range)
Rust 提供了一个非常简洁的方式，用来生成连续的数值，例如 1..5，生成从 1 到 4 的连续数字，不包含 5 ；1..=5，生成从 1 到 5 的连续数字，包含 5，它的用途很简单，常常用于循环中：
for i in1..=5 {
println!("{}",i);
}
所有权
所有的程序都必须和计算机内存打交道，如何从内存中申请空间来存放程序的运行内容，如何在不需要的时候释放这些空间，成了重中之重，也是所有编程语言设计的难点之一。在计算机语言不断演变过程中，出现了三种流派：
- 垃圾回收机制(GC) ，在程序运行时不断寻找不再使用的内存，典型代表：Java、Go
- 手动管理内存的分配和释放 , 在程序中，通过函数调用的方式来申请和释放内存，典型代表：C++
- 通过所有权来管理内存 ，编译器在编译时会根据一系列规则进行检查
其中 Rust 选择了第三种，最妙的是，这种检查只发生在编译期，因此对于程序运行期，不会有任何性能上的损失
栈(Stack)与堆(Heap)
栈和堆是编程语言最核心的数据结构，但是在很多语言中，你并不需要深入了解栈与堆。 但对于 Rust 这样的系统编程语言，值是位于栈上还是堆上非常重要, 因为这会影响程序的行为和性能。
栈和堆的核心目标就是为程序在运行时提供可供使用的内存空间。
栈
栈按照顺序存储值并以相反顺序取出值，这也被称作 后进先出 。想象一下一叠盘子：当增加更多盘子时，把它们放在盘子堆的顶部，当需要盘子时，再从顶部拿走。不能从中间也不能从底部增加或拿走盘子！
增加数据叫做 进栈 ，移出数据则叫做 出栈 。
因为上述的实现方式，栈中的所有数据都必须占用已知且固定大小的内存空间，假设数据大小是未知的，那么在取出数据时，你将无法取到你想要的数据。
堆
与栈不同，对于大小未知或者可能变化的数据，我们需要将它存储在堆上。
当向堆上放入数据时，需要请求一定大小的内存空间。操作系统在堆的某处找到一块足够大的空位，把它标记为已使用，并返回一个表示该位置地址的 指针 , 该过程被称为 在堆上分配内存 ，有时简称为 “分配”(allocating)。
接着，该指针会被推入栈中，因为指针的大小是已知且固定的，在后续使用过程中，你将通过栈中的 指针 ，来获取数据在堆上的实际内存位置，进而访问该数据。
由上可知，堆是一种缺乏组织的数据结构。想象一下去餐馆就座吃饭: 进入餐馆，告知服务员有几个人，然后服务员找到一个够大的空桌子（堆上分配的内存空间）并领你们过去。如果有人来迟了，他们也可以通过桌号（栈上的指针）来找到你们坐在哪。
所有权原则
- Rust 中每一个值都被一个变量所拥有，该变量被称为值的所有者
- 一个值同时只能被一个变量所拥有，或者说一个值只能拥有一个所有者
- 当所有者(变量)离开作用域范围时，这个值将被丢弃(drop)
变量作用域
作用域是一个变量在程序中有效的范围, 假如有这样一个变量：
let s = "hello";
变量 s 绑定到了一个字符串字面值，该字符串字面值是硬编码到程序代码中的。s 变量从声明的点开始直到当前作用域的结束都是有效的：
{ // s 在这里无效，它尚未声明
let s = "hello"; // 从此处起，s 是有效的
// 使用 s
} // 此作用域已结束，s不再有效
简而言之，s 从创建开始就有效，然后有效期持续到它离开作用域为止，可以看出，就作用域来说，Rust 语言跟其他编程语言没有区别。
变量绑定背后的数据交互
转移所有权
let x = 5;
let y = x;
代码背后的逻辑很简单, 将 5 绑定到变量 x；接着拷贝 x 的值赋给 y，最终 x 和 y 都等于 5，因为整数是 Rust 基本数据类型，是固定大小的简单值，因此这两个值都是通过自动拷贝的方式来赋值的，都被存在栈中，完全无需在堆上分配内存
其他类型的转移：
let s1 = String::from("hello");
let s2 = s1;
String 类型指向了一个堆上的空间，这里存储着它的真实数据，下面对上面代码中的 let s2 = s1 分成两种情况讨论：
- 拷贝
String和存储在堆上的字节数组 如果该语句是拷贝所有数据(深拷贝)，那么无论是String本身还是底层的堆上数据，都会被全部拷贝，这对于性能而言会造成非常大的影响 - 只拷贝
String本身 这样的拷贝非常快，因为在 64 位机器上就拷贝了8字节的指针、8字节的长度、8字节的容量，总计 24 字节，但是带来了新的问题： 一个值只允许有一个所有者 ，而现在这个值（堆上的真实字符串数据）有了两个所有者：s1和s2。
Rust 这样解决问题： 当 s1 赋予 s2 后，Rust 认为 s1 不再有效，因此也无需在 s1 离开作用域后 drop 任何东西，这就是把所有权从 s1 转移给了 s2，s1 在被赋予 s2 后就马上失效了 ，这个过程在Rust中被称之为移动。
深拷贝
首先， Rust 永远也不会自动创建数据的 “深拷贝” 。因此，任何自动的复制都不是深拷贝，可以被认为对运行时性能影响较小。
如果我们确实需要深度复制 String 中堆上的数据，而不仅仅是栈上的数据，可以使用一个叫做 clone 的方法。
let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2);
浅拷贝
浅拷贝只发生在栈上，因此性能很高，在日常编程中，浅拷贝无处不在。
let x = 5;
let y = x;
println!("x = {}, y = {}", x, y);
函数传值与返回
将值传递给函数，一样会发生 移动 或者 复制，就跟 let 语句一样，下面的代码展示了所有权、作用域的规则
fn main() {
let s = String::from("hello"); // s 进入作用域
takes_ownership(s); // s 的值移动到函数里 ...
// ... 所以到这里不再有效
let x = 5; // x 进入作用域
makes_copy(x); // x 应该移动函数里，
// 但 i32 是 Copy 的，所以在后面可继续使用 x
} // 这里, x 先移出了作用域，然后是 s。但因为 s 的值已被移走，
// 所以不会有特殊操作
fn takes_ownership(some_string: String) { // some_string 进入作用域
println!("{}", some_string);
} // 这里，some_string 移出作用域并调用 `drop` 方法。占用的内存被释放
fn makes_copy(some_integer: i32) { // some_integer 进入作用域
println!("{}", some_integer);
} // 这里，some_integer 移出作用域。不会有特殊操作
引用与借用
上节中提到，如果仅仅支持通过转移所有权的方式获取一个值，那会让程序变得复杂。 Rust 能否像其它编程语言一样，使用某个变量的指针或者引用呢？答案是可以。
Rust 通过 借用(Borrowing) 这个概念来达成上述的目的， 获取变量的引用，称之为借用(borrowing) 。正如现实生活中，如果一个人拥有某样东西，你可以从他那里借来，当使用完毕后，也必须要物归原主。
引用与解引用
常规引用是一个指针类型，指向了对象存储的内存地址。在下面代码中，我们创建一个 i32 值的引用 y，然后使用解引用运算符来解出 y 所使用的值:
fn main() {
let x = 5;
let y = &x;
assert_eq!(5, x);
assert_eq!(5, *y);
}
变量 x 存放了一个 i32 值 5。y 是 x 的一个引用。可以断言 x 等于 5。然而，如果希望对 y 的值做出断言，必须使用 *y 来解出引用所指向的值（也就是 解引用 ）。一旦解引用了 y，就可以访问 y 所指向的整型值并可以与 5 做比较
不可变引用
下面的代码，用 s1 的引用作为参数传递给 calculate_length 函数，而不是把 s1 的所有权转移给该函数：
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1);
println!("The length of '{}' is {}.", s1, len);
}
fn calculate_length(s: &String) -> usize {
s.len()
}
能注意到两点：
- 无需像之前一样：先通过函数参数传入所有权，然后再通过函数返回来传出所有权，代码更加简洁
calculate_length的参数s类型从String变为&String
这里，& 符号即是引用，它们允许你使用值，但是不获取所有权，通过 &s1 语法，我们创建了一个 指向 s1 的引用 ，但是并不拥有它。因为并不拥有这个值，当引用离开作用域后，其指向的值也不会被丢弃。
这里因为是借用的变量，所以不能够对变量进行修改
fn calculate_length(s: &String) -> usize {
s.push_str("string"); // 编译时错误，提示不能对一个borrow的变量进行修改
return s.len();
}
正如变量默认不可变一样，引用指向的值默认也是不可变的
可变引用
只需要一个小调整，即可修复上面代码的错误：
fn main() {
let mut s = String::from("hello");
change(&mut s);
}
fn change(some_string: &mut String) {
some_string.push_str(", world");
}
首先，声明 s 是可变类型，其次创建一个可变的引用 &mut s 和接受可变引用参数 some_string: &mut String 的函数。
可变引用同时只能存在一个
不过可变引用并不是随心所欲、想用就用的，它有一个很大的限制： 同一作用域，特定数据只能有一个可变引用 ：
fn borrow_error() {
let mut s = String::from("abc");
let r1 = &mut s;
let r2 = &mut s;
println!("r1 = {}, r2 = {}", r1, r2);
}
报错：
cannot borrow `s` as mutable more than once at a time
second mutable borrow occurs here**rustc**[Click for full compiler diagnostic](rust-analyzer-diagnostics-view:/diagnostic%20message%20%5B0%5D?0#file%3A%2F%2F%2FUsers%2Fzhaoyang%2Fpri%2Frust_project%2Fworld_hello%2Fsrc%2Fmain.rs)
[main.rs(130, 14): ]("~/pri/rust_project/world_hello/src/main.rs")first mutable borrow occurs here
[main.rs(132, 34): ]("~/pri/rust_project/world_hello/src/main.rs")first borrow later used here
这段代码出错的原因在于，第一个可变借用 r1 必须要持续到最后一次使用的位置 println!，在 r1 创建和最后一次使用之间，我们又尝试创建第二个可变借用 r2。
这种限制的好处就是使 Rust 在编译期就避免数据竞争，数据竞争可由以下行为造成：
- 两个或更多的指针同时访问同一数据
- 至少有一个指针被用来写入数据
- 没有同步数据访问的机制
数据竞争会导致未定义行为，这种行为很可能超出我们的预期，难以在运行时追踪，并且难以诊断和修复。而 Rust 避免了这种情况的发生，因为它甚至不会编译存在数据竞争的代码！
大括号可以帮我们解决一些编译不通过的问题，通过手动限制变量的作用域：
fn borrow_error() {
let mut s = String::from("abc");
{
let r1 = &mut s;
}
let r2 = &mut s;
}
可变引用与不可变引用不能同时存在
fn borrow_error() {
let mut s = String::from("hello");
let r1 = &s; // 没问题
let r2 = &s; // 没问题
/**
* A mutable variable, reference, or pointer.
mut can be used in several situations. The first is mutable variables, which can be used anywhere you can bind a value to a variable name. Some examples:
*/
let r3 = &mut s; // 大问题
println!("{}, {}, and {}", r1, r2, r3);
}
悬垂引用(Dangling References)
悬垂引用也叫做悬垂指针，意思为指针指向某个值后，这个值被释放掉了，而指针仍然存在，其指向的内存可能不存在任何值或已被其它变量重新使用。在 Rust 中编译器可以确保引用永远也不会变成悬垂状态：当你获取数据的引用后，编译器可以确保数据不会在引用结束前被释放，要想释放数据，必须先停止其引用的使用。
fn dangling_reference() {
let ref_to_nothing = dangle();
}
fn dangle() -> &String {
let s = String::from("value");
return &s;
}
会报编译时错误：The String type is the most common string type that has ownership over the contents of the string. It has a close relationship with its borrowed counterpart, the primitive [str]
当引用指向的值已经被释放，但还是返回这个引用的时候就会报错，因为 s 是在 dangle 函数内创建的，当 dangle 的代码执行完毕后，s 将被释放，但是此时我们又尝试去返回它的引用。这意味着这个引用会指向一个无效的 String，这可不对！
总的来说，借用规则如下：
- 同一时刻，你只能拥有要么一个可变引用, 要么任意多个不可变引用
- 引用必须总是有效的
printf “%x\n” 1798
401
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
