文章目录
一、概述
fn greet_world() {
println!("Hello, world!"); // 这里的第一个感叹号表示这是一个宏，这个我们稍后会讨论。
let southern_germany = "Grüß Gott!"; // Rust中的赋值，更恰当的说法叫作变量绑定，使用let关键字。
let japan = "ハロー・ワールド"; // 对Unicode的支持，是“开箱即用”的。
let regions = [southern_germany, japan]; // 数组字面量使用方括号。
for region in regions.iter() {
// 很多类型都有iter()方法，此方法会返回一个迭代器。
println!("{}", ®ion); // 此处的和符号（&）表示“借用”region的值，用于只读的访问。
}
}
fn main() {
greet_world(); // 调用一个函数。要注意紧跟在函数名后面的圆括号。
}
println!是宏, 因为在底层做了大量类型检测, 所以才支持任意类型数据类型
fn main() {
// <1> <2>跳过表头行和只含有空白符的行
let penguin_data = "\
common name,length (cm)
Little penguin,33
Yellow-eyed penguin,65
Fiordland penguin,60
Invalid,data
";
let records = penguin_data.lines();
for (i, record) in records.enumerate() {
if i == 0 || record.trim().len() == 0 {
// 跳过表头行和只含有空白符的行
continue;
}
let fields: Vec<_> = record // 从一行文本开始
.split(',') // <5>将record分割（split）为多个子字符串
.map(|field| field.trim()) // <6>修剪（trim）掉每个字段中两端的空白符
.collect(); // <7>构建具有多个字段的集合
// 条件编译: 如果cargo run 添加了 --release 参数则不满足此条件
if cfg!(debug_assertions) {
// <8>cfg!用于在编译时检查配置
eprintln!("debug: {:?} -> {:?}", record, fields); // <9>eprintln!用于输出到标准错误（stderr）
}
let name = fields[0];
// 如果无法从上下文推断出类型, 就需要人为指定类型(如下文的f32)
if let Ok(length) = fields[1].parse::<f32>() {
// <10>试图把该字段解析为一个浮点数
println!("{}, {}cm", name, length); // <11>println!用于输出到标准输出（stdout）
}
}
}
// cargo r
debug: " Little penguin,33" -> ["Little penguin", "33"]
Little penguin, 33cm
debug: " Yellow-eyed penguin,65" -> ["Yellow-eyed penguin", "65"]
Yellow-eyed penguin, 65cm
debug: " Fiordland penguin,60" -> ["Fiordland penguin", "60"]
Fiordland penguin, 60cm
debug: " Invalid,data" -> ["Invalid", "data"]
// cargo r --release
Little penguin, 33cm
Yellow-eyed penguin, 65cm
Fiordland penguin, 60cm
1.1 安全性
1.1.1 垂悬指针
#[derive(Debug)] // 允许使用println! 宏来输出枚举体Cereal（谷类）。
enum Cereal {
// enum（枚举体，是enumeration的缩写）是一个具有固定数量的合法变体的类型。
Barley,
Millet,
Rice,
Rye,
Spelt,
Wheat,
}
fn main() {
let mut grains: Vec<Cereal> = vec![]; // 初始化一个空的动态数组，其元素类型为Cereal。
grains.push(Cereal::Rye); // 向动态数组grains（粮食）中添加一个元素。
drop(grains); // 删除grains和其中的数据。
println!("{:?}", grains); // 试图访问已删除的值。
}
error[E0382]: borrow of moved value: `grains`
--> src/main.rs:16:22
|
13 | let mut grains: Vec<Cereal> = vec![]; // 初始化一个空的动态数组，其元素类型为Cereal。
| ---------- move occurs because `grains` has type `Vec<Cereal>`, which does not implement the `Copy` trait
14 | grains.push(Cereal::Rye); // 向动态数组grains（粮食）中添加一个元素。
15 | drop(grains); // 删除grains和其中的数据
| ------ value moved here
16 | println!("{:?}", grains); // 试图访问已删除的值。
| ^^^^^^ value borrowed here after move
|
// 因为 Cerel 没有实现 Copy trait, 所以 Vec<Cerel> 没有实现 Copy trait, 所以 drop(grains) 不会 Copy 而回 move 其所有权, 所以 grains 变量已回收, 所以 println!("{:?}", grains) 访问不到已回收的变量就会编译报错
1.1.2 数据竞争
运行结果不确定, 即main退出时data的值不确定, 因为线程是os调度的故无法保证顺序
use std::thread; // 把多线程的能力导入当前的局部作用域。
fn main() {
let mut data = 100;
thread::spawn(|| { data = 500; }); // thread::spawn() 接收一个闭包作为参数。
thread::spawn(|| { data = 1000; });
println!("{}", data);
}
1. E0373: 主线程的变量 data, 被线程 thread::spawn() borrow 了, 导致其 outlive 了
2. E0499: 两个 thread::spawn() borrow 了变量 data 两次
3. E0502: 把 mutable 的变量, borrow as immutable 了
1.1.3 迭代器失效
fn main() {
let fruit = vec!['🥝', '🍌', '🍇'];
let buffer_overflow = fruit[4]; // <1> Rust 竟然不会在编译期检查出此错误, 而会Rust会让程序崩溃，它而不会把一个无效的内存位置赋值给一个变量
assert_eq!(buffer_overflow, '🍉') // <2>
}
// cargo r 会让程序 panic
thread 'main' panicked at src/main.rs:3:32:
index out of bounds: the len is 3 but the index is 4
fn main() {
let mut letters = vec![ // <1>
"a", "b", "c"
];
for letter in letters {
println!("{}", letter);
letters.push(letter.clone()); // <2>
}
}
这段 Rust 代码的错误是因为在 for 循环中，letters 集合的所有权被移动到了循环中，这意味着在 for 循环之后，你就不能再使用 letters 了。然而，在循环体内部，尝试使用 letters.push() 向 letters 添加元素，这会导致编译错误，因为 letters 已经被移动，它的所有权已经不在原来的作用域内了。
如果注释掉一行, 则可正常运行:
在 Rust 中，当你对一个集合使用 for 循环时，会隐式地调用集合的 .into_iter() 方法，这个方法会消耗（取得所有权并移动）集合。为了解决这个问题，你可以通过借用 letters 来避免所有权被移动，即在 for 循环中使用 &letters 而不是 letters。
修复后的代码如下:
fn main() {
let mut letters = vec![
"a", "b", "c",
];
for letter in &letters { // 使用借用来避免所有权问题
println!("{}", letter);
letters.push(letter.clone()); // 这也会导致无限循环
}
}
但是，即便这样修改，代码依然存在逻辑问题。修复所有权问题后，这段代码会产生无限循环，因为它在循环中不断向 letters 中添加元素，循环永远不会结束。通常，你不能在遍历集合的同时修改它，因为这样做会导致不确定的行为或无限循环。
如果你需要在遍历时修改集合，你应该考虑其他的逻辑方法来实现你的需求，例如先收集需要添加的元素，然后在循环外部添加它们，或者使用其他类型的循环结构。
所以, 可以改成如下:
1.2 vscode 設置
DEBUG 設置：rust-analyzer + codelldb
二、基础语法
fn main() {
//<1>
let a = 10; //<2>
let b: i32 = 20; //<3>
let c = 30i32; //<4>
let d = 30_i32; //<5>
let e = add(add(a, b), add(c, d));
println!("( a + b ) + ( c + d ) = {}", e);
}
fn add(i: i32, j: i32) -> i32 {
//<6>
i + j //<7>
}
// cargo r
( a + b ) + ( c + d ) = 90
宏返回的是代码, 而不是值, 每种数据类型都有自己转换字符串的方式, 而println!()负责找到将参数转换为字符串的确切方法并调用此方法.
f32和f64只实现了std::cmp::PartialEq这个trait, 而其他数字类型还实现了std::cmp::Eq, 所以我们尽量避免测试浮点数的相等性.
2.1 循环
for循环的所有权, 默认会转移所有权, &会引用, &mut会可变引用
匿名循环
fn main() {
for _ in 0..10 {
print!("a")
}
}
尽量避免手动管理索引变量, 下例不推荐
- 从性能角度, 每次
collection[i]都需要编译器检查越界 - 从安全角度, 周期性地访问
collection会引入使其改变的可能性
let collection = [1, 2, 3, 4, 5];
for i in 0..collection.len() {
let item = collection[i];
// ...
}
continue跳出循环
fn main() {
for n in 0..10 {
if n % 2 == 0 {
continue;
}
print!("{}", n)
}
}
通过循环, 测试1s能执行多少次加法运算
use std::time::{Duration, Instant}; //<1>
fn main() {
let mut count = 0;
let time_limit = Duration::new(1, 0); //<2>
let start = Instant::now(); //<3>
while (Instant::now() - start) < time_limit {
//<4>
count += 1;
}
println!("{}", count);
}
// cargo r
38345513
如果无限循环, 用loop替代while, 当遇到break会停止
loop {
println!("a")
}
可用标签退出循环, 在for关键词之前加了'outer'标签即可
fn main() {
'outer: for x in 0.. {
for y in 0.. {
for z in 0.. {
if x + y + z > 1000 {
break 'outer;
}
println!("{}, {}, {}", x, y, z)
}
}
}
}
break 可在退出循环的同时, 返回值
fn main() {
let n = loop {
break 123;
};
println!("{}", n); // 输出“123”。
}
rust 大部分都是表达式, 不返回值的才不是表达式, 具体有以下3种情况不是表达式
- 以分号
;结尾的是表达式语句 - 用赋值操作符
=绑定一个名字到一个值上, 是声明语句 - 类型声明, 包括函数
fn和用struct或enum声明的数据类型, 是声明语句
rust中, 没有返回值, 则返回()类型
match可匹配范围类型
match item {
0 => {}, ⇽--- 匹配一个单值。这时是不需要任何运算符的。
10 ..= 20 => {}, ⇽--- ..= 语法匹配一个包含范围（inclusive range）。
40 | 80 => {}, ⇽--- 竖线（|）表示匹配其中任意一个值的情况。
_ => {}, ⇽--- 下画线（_）在这里代表匹配所有值。
}
2.2 引用
如果一个变量a是一个大数组, 则r就是变量a的引用, 其实就是存储了变量a的地址.
fn main() {
let a = 42; // r是对a的引用
let r = &a; // 实现a与a相加（通过解除引用），并将结果赋值给6
let b = a + *r;
let c = a + r;
println!("a + a = {}", b); // 输出"a + a = 84"
println!("a + a = {}", c); // 输出"a + a = 84"
}
// cargo r
a + a = 84
a + a = 84
fn main() {
let needle = 0o204; // 以 `0o` 或 `0O` 开头的字面量表示八进制数。因此，`0o204` 表示的十进制值为 2*8^2 + 0*8^1 + 1*8^0 = 128+0+4 = 132。
// 二进制数以 `0b` 开头，十六进制数以 `0x` 开头。以下是示例：
// 二进制表示法：`0b1010` 表示十进制中的 `10`（即 `1*2^3 + 0*2^2 + 1*2^1 + 0*2^0`）。
// 十六进制表示法：`0x1A` 表示十进制中的 `26`（即 `1*16^1 + 10*16^0`）。
println!("needle is {}", needle);
let haystack = [1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147];
for item in &haystack {
// 在数组haystack中遍历数组元素的引用。
if *item == needle {
println!("{}", item); // *item，这个语法解引用item，返回它所指向的对象。
}
}
}
// cargo r
needle is 132
2.3 生命周期
在rust无法推断出引用的生命周期时, 就需要手动指明生命周期
fn add_with_lifetimes<'a, 'b>(i: &'a i32, j: &'b i32) -> i32 {
*i + *j // 加法运算的两个操作数是i和j所指向的值
}
fn main() {
let a = 10;
let b = 20;
let res = add_with_lifetimes(&a, &b); // &a是对值10的引用，&b是对值20的引用
println!("{}", res);
}
// cargo r
30
2.4 泛型
rust的操作符均是trait方法的语法糖, rust用此支持操作符重载, a+b会转换为a.add(b)
use std::ops::Add; // 从std::ops中导入Add这个trait到当前的局部作用域中。
use std::time::Duration; // 从std::time中导入Duration类型到当前的局部作用域中。
fn add<T: Add<Output = T>>(i: T, j: T) -> T {
// add() 函数的参数能接收实现了std::ops::Add的任何类型。
i + j
}
fn main() {
let floats = add(1.2, 3.4); // 使用浮点数作为参数调用add()。
let ints = add(10, 20); // 使用整数作为参数调用add()。
let durations = add(Duration::new(5, 0), Duration::new(10, 0)); // 使用Duration类型的值作为参数调用add()，Duration类型表示两个时间点之间的时间间隔。
println!("{}", floats);
println!("{}", ints);
println!("{:?}", durations); // std::time::Duration没有实现std::fmt::Display这个trait，所以我们退一步使用Std::fmt::Debug这个trait。
}
// cargo r
4.6
30
15s
2.5 实战grep项目
rust有很多类型的字符串, 例如String, str
- 如果初学者分不清就都先用
String即可, 它最接近其他语言你认识的字符串类型, 有很多methods str高性能, 但功能较少, 一旦被创建就不能扩大缩小, 比原始内存数组多保证了所有字符都是UTF-8, 通常以&str的引用形式存在, 其内部包含指向str数据的引用和长度.- 因为rust编译器需在栈中存固定大小的变量, 而一个
str的值可为任意长度, 故只能通过引用来将其存储为局部变量
- 因为rust编译器需在栈中存固定大小的变量, 而一个
String是有所有权的类型, 可对数据读/写, 且负责在离开作用域时删除其拥有的值
&str只是一个借用的类型, 只是只读
fn main() {
let search_term = "picture";
let quote = "\
Every face, every shop, bedroom window, public-house, and
dark square is a picture feverishly turned--in search of what?
It is the same with books. What do we seek through millions of pages?";
for (i, line) in quote.lines().enumerate() {
// <1>
if line.contains(search_term) {
let line_num = i + 1; // <2>
println!("{}: {}", line_num, line);
}
}
}
// cargo r
2: dark square is a picture feverishly turned--in search of what?
2.6 数组
2.6.1 数组和切片
数组类型[T: n]有编译期长度, 切片类型[T]没有
因数组长度不同, [u8; 3]和[u8; 4]是不同类型, 而为每个数组类型都实现一套方法就太笨重繁琐了, 所以实际使用中, 大多数数组操作都是通过切片类型T执行的, 且常用切片的引用形式&[T]
fn main() {
let one = [1, 2, 3];
let two: [u8; 3] = [1, 2, 3];
let blank1 = [0; 3];
let blank2: [u8; 3] = [0; 3];
let arrays = [one, two, blank1, blank2];
for a in &arrays {
print!("{:?}: ", a);
for n in a.iter() {
print!("\t{} + 10 = {}", n, n + 10);
}
let mut sum = 0;
for i in 0..a.len() {
sum += a[i];
}
println!("\t(Σ{:?} = {})", a, sum);
}
}
// cargo r
[1, 2, 3]: 1 + 10 = 11 2 + 10 = 12 3 + 10 = 13 (Σ[1, 2, 3] = 6)
[1, 2, 3]: 1 + 10 = 11 2 + 10 = 12 3 + 10 = 13 (Σ[1, 2, 3] = 6)
[0, 0, 0]: 0 + 10 = 10 0 + 10 = 10 0 + 10 = 10 (Σ[0, 0, 0] = 0)
[0, 0, 0]: 0 + 10 = 10 0 + 10 = 10 0 + 10 = 10 (Σ[0, 0, 0] = 0)
2.6.2 动态数组
fn main() {
let ctx_lines = 2;
let needle = "oo";
let haystack = "\
Every face, every shop,
bedroom window, public-house, and
dark square is a picture
feverishly turned--in search of what?
It is the same with books.
What do we seek
through millions of pages?";
let mut tags: Vec<usize> = vec![]; // <1>
let mut ctx: Vec<Vec<(
usize, String)>> = vec![]; // <2>
for (i, line) in haystack.lines().enumerate() { // <3>
if line.contains(needle) {
tags.push(i);
let v = Vec::with_capacity(2*ctx_lines + 1); // <4>
ctx.push(v);
println!("{}, {}, {:?}, {:?}", line, i, tags, ctx)
}
}
if tags.is_empty() { // <5>
return;
}
for (i, line) in haystack.lines().enumerate() { // <6>
for (j, tag) in tags.iter().enumerate() {
let lower_bound =
tag.saturating_sub(ctx_lines); // <7>
let upper_bound =
tag + ctx_lines;
if (i >= lower_bound) && (i <= upper_bound) {
let line_as_string = String::from(line); // <8>
let local_ctx = (i, line_as_string);
ctx[j].push(local_ctx);
}
}
}
println!("{}", ctx);
for local_ctx in ctx.iter() {
for &(i, ref line) in local_ctx.iter() { // <9>
let line_num = i + 1;
println!("{}: {}", line_num, line);
}
}
}
// cargo r
bedroom window, public-house, and, 1, [1], [[]]
It is the same with books., 4, [1, 4], [[], []]
[
[(0, "Every face, every shop,"), (1, "bedroom window, public-house, and"), (2, "dark square is a picture"), (3, "feverishly turned--in search of what?")],
[(2, "dark square is a picture"), (3, "feverishly turned--in search of what?"), (4, "It is the same with books."), (5, "What do we seek"), (6, "through millions of pages?")]
]
1: Every face, every shop,
2: bedroom window, public-house, and
3: dark square is a picture
4: feverishly turned--in search of what?
3: dark square is a picture
4: feverishly turned--in search of what?
5: It is the same with books.
6: What do we seek
7: through millions of pages?
2.6.3 初始化
Vec<String>
fn main() {
let a = vec![
"gta".to_string(),
"gta(1)".to_string(),
"gta".to_string(),
"gta(2)".to_string(),
];
let mut grid: [[i32; 3]; 3] = [[1, 3, 1], [1, 5, 1], [4, 2, 1]]; // 初始化 3*3 的数组
}
2.7 包含第三方库
cargo new grep-lite --vcs none, 其中--vcs none是不进行git init的意思
use regex::Regex; // <1>
fn main() {
let re = Regex::new("picture").unwrap(); // <2>用unwrap() 解包装一个Result
let quote = "Every face, every shop, bedroom window, public-house, and
dark square is a picture feverishly turned--in search of what?
It is the same with books. What do we seek through millions of pages?";
for line in quote.lines() {
let contains_substring = re.find(line);
match contains_substring {
// <3>
Some(_) => println!("{}", line), // <4>这里的下画线是通配符，匹配所有值
None => (), // <5>
}
}
}
cargo doc可生成本地文档, cargo doc --open可浏览器查看文档
(base) tree -d -L 1 target/doc
target/doc
├── aho_corasick
├── grep_lite
├── implementors
├── memchr
├── regex
├── regex_syntax
└── src
rustup doc会在本地打开rust文档
2.8 命令行参数
cargo add clap@2添加依赖库
use clap::{App, Arg};
use regex::Regex; // 导入clap::App和clap::Arg对象到当前的局部作用域。
fn main() {
let args = App::new("grep-lite") // 逐步构建命令行参数解析器。每个参数对应一个Arg。在本例中，我们只需要一个参数。
.version("0.1")
.about("searches for patterns")
.arg(
// 必备的参数
Arg::with_name("pattern")
.help("The pattern to search for")
.takes_value(true)
.required(true),
)
.get_matches();
let pattern = args.value_of("pattern").unwrap(); // 提取pattern参数。
let re = Regex::new(pattern).unwrap();
let quote = "Every face, every shop, bedroom window, public-house, and
dark square is a picture feverishly turned--in search of what?
It is the same with books. What do we seek through millions of pages?";
for line in quote.lines() {
match re.find(line) {
Some(_) => println!("{}", line),
None => (),
}
}
}
// cargo run
error: The following required arguments were not provided:
<pattern>
USAGE:
grep-lite <pattern>
For more information try --help
// ./target/debug/grep-lite --help
grep-lite 0.1
searches for patterns
USAGE:
grep-lite <pattern>
FLAGS:
-h, --help Prints help information
-V, --version Prints version information
ARGS:
<pattern> The pattern to search for
// cargo r -- picture
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `target/debug/grep-lite picture`
pattern is picture
dark square is a picture feverishly turned--in search of what?
// cargo r -- o
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `target/debug/grep-lite o`
pattern is o
Every face, every shop, bedroom window, public-house, and
dark square is a picture feverishly turned--in search of what?
It is the same with books. What do we seek through millions of pages?
2.9 读文件
2.9.1 手动循环读文件
use std::fs::File;
use std::io::prelude::*;
use std::io::BufReader;
fn main() {
let f = File::open("readme.md").unwrap(); // 创建一个文件需要一个path（路径）参数，并且还需要处理当文件不存在时的错误情况。本例中如果readme.md不存在，程序会崩溃。
let mut reader = BufReader::new(f);
let mut line = String::new(); // 在整个程序的生命周期中，我们将反复重用这个String对象。
loop {
let len = reader.read_line(&mut line).unwrap(); // 从磁盘中读取可能会失败，所以我们需要显式地处理错误情况。在本例中，遇到错误情况时程序直接崩溃。
if len == 0 {
break;
}
println!("{} ({} bytes long)", line, len);
line.truncate(0); // 将String收缩到长度为0，防止有之前行的内容遗留下来。
}
}
// 运行效果如下：
// cat readme.md
a
bc
def
// cargo r -q
a
(2 bytes long)
bc
(3 bytes long)
def
(4 bytes long)
2.9.2 迭代器读文件
use std::fs::File;
use std::io::prelude::*;
use std::io::BufReader;
fn main() {
let f = File::open("readme.md").unwrap();
let reader = BufReader::new(f);
for line_ in reader.lines() {
// <1>
let line = line_.unwrap(); // <2>
println!("{} ({} bytes long)", line, line.len());
}
}
// 运行效果如下：
// cat readme.md
a
bc
def
// cargo run -q
a (1 bytes long)
bc (2 bytes long)
def (3 bytes long)
2.9.3 配合命令行参数读文件
use clap::{App, Arg};
use regex::Regex;
use std::fs::File;
use std::io::prelude::*;
use std::io::BufReader;
fn main() {
let args = App::new("grep-lite")
.version("0.1")
.about("searches for patterns")
.arg(
Arg::with_name("pattern")
.help("The pattern to search for")
.takes_value(true)
.required(true),
)
.arg(
Arg::with_name("input")
.help("File to search")
.takes_value(true)
.required(true),
)
.get_matches();
let pattern = args.value_of("pattern").unwrap();
let re = Regex::new(pattern).unwrap();
let input = args.value_of("input").unwrap();
let f = File::open(input).unwrap();
let reader = BufReader::new(f);
for line_ in reader.lines() {
let line = line_.unwrap();
match re.find(&line) {
// line是String类型，但是re.find() 方法需要 &str类型作为参数。
Some(_) => println!("{}", line),
None => (),
}
}
}
// 运行效果如下：
// cat readme.md
a
bc
def
// cargo r -q
error: The following required arguments were not provided:
<pattern>
<input>
USAGE:
grep-lite <pattern> <input>
For more information try --help
// cargo r -q -- picture readme.md
// cargo r -q -- a readme.md
a
// cargo r -q -- b readme.md
bc
// cargo r -q -- f readme.md
def
2.10 读 stdin
use clap::{Arg, Command};
use regex::Regex;
use std::fs::File;
use std::io;
use std::io::prelude::*;
use std::io::BufReader;
fn process_lines<T: BufRead + Sized>(reader: T, re: Regex) {
for line_ in reader.lines() {
let line = line_.unwrap();
match re.find(&line) {
// line是String类型，但是re.find() 接收类型为 &str的参数。
Some(_) => println!("{}", line),
None => (),
}
}
}
fn main() {
let args = Command::new("grep-lite")
.version("0.1")
.about("searches for patterns")
.arg(
Arg::new("pattern")
.help("The pattern to search for")
.required(true),
)
.arg(Arg::new("input").help("File to search").required(false))
.get_matches();
let pattern = args.get_one::<String>("pattern").unwrap();
let re = Regex::new(pattern).unwrap();
let input = args
.get_one::<String>("input")
.map(|s| s.as_str())
.unwrap_or("-");
if input == "-" {
let stdin = io::stdin();
let reader = stdin.lock();
process_lines(reader, re);
} else {
let f = File::open(input).unwrap();
let reader = BufReader::new(f);
process_lines(reader, re);
}
}
// cargo r -q
error: The following required arguments were not provided:
<pattern>
USAGE:
grep-lite <pattern> [input]
For more information try --help
// cargo run -q -- picture
a picture is good, is it?
a picture is good, is it?
^C
三、复合数据结构
3.1 普通函数
用#![allow(unused_variables)]可在编码时放宽编译器警告
!是Never类型, 表示函数永不返回, 如下
#[allow(dead_code)] // <4>放宽一个未使用函数的编译器警告。
fn read(f: &mut File, save_to: &mut Vec<u8>) -> ! { // <5>返回类型会告知Rust编译器，此函数永不返回
unimplemented!() // <6>如果执行到这个宏，那么程序会崩溃。
}
若忘记在loop中加break, 则编译器会报错: 不应返回Never类型
fn forever() -> ! {
loop { // 除非包含一个break，否则loop将永远不会结束循环。这阻止了此函数返回。
//...
// break;
};
}
3.2 struct
#[derive(Debug)] // <1>
struct File {
name: String,
data: Vec<u8>, // <2>
}
fn main() {
let f1 = File {
name: String::from("f1.txt"), // <3>
data: Vec::new(), // <4>
};
let f1_name = &f1.name; // <5>
let f1_length = &f1.data.len(); // <5>
println!("{:?}", f1);
println!("{} is {} bytes long", f1_name, f1_length);
}
#![allow(unused_variables)] // <1>
#[derive(Debug)] // <2>
struct File {
name: String,
data: Vec<u8>,
}
fn open(f: &mut File) -> bool { // <3>
true
}
fn close(f: &mut File) -> bool { // <3>
true
}
fn read(
f: &File,
save_to: &mut Vec<u8>,
) -> usize { // <4>
let mut tmp = f.data.clone(); // <5>
let read_length = tmp.len();
save_to.reserve(read_length); // <6>
save_to.append(&mut tmp); // <7>
read_length
}
fn main() {
let mut f2 = File {
name: String::from("2.txt"),
data: vec![114, 117, 115, 116, 33],
};
let mut buffer: Vec<u8> = vec![];
open(&mut f2); // <8>
let f2_length = read(&f2, &mut buffer); // <8>
close(&mut f2); // <8>
let text = String::from_utf8_lossy(&buffer); // <9>
println!("{:?}", f2);
println!("{} is {} bytes long", &f2.name, f2_length);
println!("{}", text) // <10>
}
// cargo r
File { name: "2.txt", data: [114, 117, 115, 116, 33] }
2.txt is 5 bytes long
rust!
3.3 用 impl 为 struct 添加方法
Rust 约定用 new() 初始化，虽然 new() 并不是关键字。
#[derive(Debug)]
struct File {
name: String,
data: Vec<u8>,
}
impl File {
fn new(name: &str) -> File { // <1> As `File::new()` is a completely normal function--rather than something blessed by the language--we need to tell Rust that it will be returning a `File` from this function
File { // <2>
name: String::from(name), // <2> `File::new()` does little more than encapsulate the object creation syntax
data: Vec::new(), // <2>
}
}
// fn len(&self) -> usize { // <3> `File::len()` takes an implicit argument `self`. You'll notice that there is no explicit argument provided on line 25.
// self.data.len() // <4> `usize` is the type returned by `Vec<T>::len()`, which is sent directly through to the caller
// }
}
fn main() {
let f3 = File::new("f3.txt");
let f3_name = &f3.name; // <5> Fields are private by default, but can be accessed within the module that defines the struct. The module system is discussed further on in the chapter.
//let f3_length = f3.len();
let f3_length = f3.data.len();
println!("{:?}", f3);
println!("{} is {} bytes long", f3_name, f3_length);
}
配合读取文件的代码如下：
#![allow(unused_variables)]
#[derive(Debug)]
struct File {
name: String,
data: Vec<u8>,
}
impl File {
fn new(name: &str) -> File {
File {
name: String::from(name),
data: Vec::new(),
}
}
fn new_with_data(
name: &str,
data: &Vec<u8>,
) -> File { // <1>
let mut f = File::new(name);
f.data = data.clone();
f
}
fn read(
self: &File,
save_to: &mut Vec<u8>,
) -> usize { // <2>
let mut tmp = self.data.clone();
let read_length = tmp.len();
save_to.reserve(read_length);
save_to.append(&mut tmp);
read_length
}
}
fn open(f: &mut File) -> bool { // <3>
true
}
fn close(f: &mut File) -> bool {
true
}
fn main() {
let f3_data: Vec<u8> = vec![ // <3>
114, 117, 115, 116, 33
];
let mut f3 = File::new_with_data("2.txt", &f3_data);
let mut buffer: Vec<u8> = vec![];
open(&mut f3);
let f3_length = f3.read(&mut buffer); // <4>
close(&mut f3);
let text = String::from_utf8_lossy(&buffer);
println!("{:?}", f3);
println!("{} is {} bytes long", &f3.name, f3_length);
println!("{}", text);
}
// cargo run -q
File { name: "2.txt", data: [114, 117, 115, 116, 33] }
2.txt is 5 bytes long
rust!
3.4 返回错误信息
3.4.1 unsafe 读写全局变量
use rand::{random}; // <1>
static mut ERROR: isize = 0; // <2>
struct File; // <3>
#[allow(unused_variables)]
fn read(f: &File, save_to: &mut Vec<u8>) -> usize {
if random() && random() && random() { // <4>
unsafe {
ERROR = 1; // <5>
}
}
0 // <6>
}
#[allow(unused_mut)] // <7>
fn main() {
let mut f = File;
let mut buffer = vec![];
read(&f, &mut buffer);
unsafe { // <8>
if ERROR != 0 {
panic!("An error has occurred!")
}
}
}
3.4.2 Result<T, E>
use rand::prelude::*; // <1>
fn one_in(denominator: u32) -> bool {
// <2>
thread_rng().gen_ratio(1, denominator) // <3>
}
#[derive(Debug)]
struct File {
name: String,
data: Vec<u8>,
}
impl File {
fn new(name: &str) -> File {
File {
name: String::from(name),
data: Vec::new(),
} // <4>
}
fn new_with_data(name: &str, data: &Vec<u8>) -> File {
let mut f = File::new(name);
f.data = data.clone();
f
}
fn read(self: &File, save_to: &mut Vec<u8>) -> usize {
// <5>
let mut tmp = self.data.clone();
let read_length = tmp.len();
save_to.reserve(read_length);
save_to.append(&mut tmp);
read_length // <6>
}
}
fn open(f: File) -> Result<File, String> {
if one_in(10_000) {
// <7>
let err_msg = String::from("Permission denied");
return Err(err_msg);
}
Ok(f)
}
fn close(f: File) -> Result<File, String> {
if one_in(100_000) {
// <8>
let err_msg = String::from("Interrupted by signal!");
return Err(err_msg);
}
Ok(f)
}
fn main() {
let f4_data: Vec<u8> = vec![114, 117, 115, 116, 33];
let mut f4 = File::new_with_data("4.txt", &f4_data);
let mut buffer: Vec<u8> = vec![];
f4 = open(f4).unwrap(); // <9>
let f4_length = f4.read(&mut buffer); // <9>
f4 = close(f4).unwrap(); // <9>
let text = String::from_utf8_lossy(&buffer);
println!("{:?}", f4);
println!("{} is {} bytes long", &f4.name, f4_length);
println!("{}", text);
}
// cargo r
File { name: "4.txt", data: [114, 117, 115, 116, 33] }
4.txt is 5 bytes long
rust!
3.5 enum
#[derive(Debug)] // <1>
enum Event {
Update, // <2>
Delete, // <2>
Unknown, // <2>
}
type Message = String; // <3>
fn parse_log(line: &str) -> (Event, Message) { // <4>
let parts: Vec<_> = line // <5>
.splitn(2, ' ')
.collect(); // <6>
if parts.len() == 1 { // <7>
return (Event::Unknown, String::from(line))
}
let event = parts[0]; // <8>
let rest = String::from(parts[1]); // <8>
match event {
"UPDATE" | "update" => (Event::Update, rest), // <9>
"DELETE" | "delete" => (Event::Delete, rest), // <9>
_ => (Event::Unknown, String::from(line)), // <10>
}
}
fn main() {
let log = "BEGIN Transaction XK342
UPDATE 234:LS/32231 {\"price\": 31.00} -> {\"price\": 40.00}
DELETE 342:LO/22111";
for line in log.lines() {
let parse_result = parse_log(line);
println!("{:?}", parse_result);
}
}
// cargo run -q
(Unknown, "BEGIN Transaction XK342")
(Update, "234:LS/32231 {\"price\": 31.00} -> {\"price\": 40.00}")
(Delete, "342:LO/22111")
3.5.1 enum 可带参数
enum Suit {
Clubs,
Spades,
Diamonds,
Hearts, // 枚举体中的最后一个元素也可以用逗号结尾，方便以后对代码重构。
}
enum Card {
King(Suit), // 人头牌（通常指扑克牌中的K、Q和J）有花色。
Queen(Suit),
Jack(Suit),
Ace(Suit),
Pip(Suit, usize), // 点数牌有花色和点数。
}
3.5.2 用枚举管理内部状态
#[derive(Debug, PartialEq)]
enum FileState {
Open,
Closed,
}
#[derive(Debug)]
struct File {
name: String,
data: Vec<u8>,
state: FileState,
}
impl File {
fn new(name: &str) -> File {
File {
name: String::from(name),
data: Vec::new(),
state: FileState::Closed,
}
}
fn read(
self: &File,
save_to: &mut Vec<u8>,
) -> Result<usize, String> {
if self.state != FileState::Open {
return Err(String::from("File must be open for reading"));
}
let mut tmp = self.data.clone();
let read_length = tmp.len();
save_to.reserve(read_length);
save_to.append(&mut tmp);
Ok(read_length)
}
}
fn open(mut f: File) -> Result<File, String> {
f.state = FileState::Open;
Ok(f)
}
fn close(mut f: File) -> Result<File, String> {
f.state = FileState::Closed;
Ok(f)
}
fn main() {
let mut f5 = File::new("5.txt");
let mut buffer: Vec<u8> = vec![];
if f5.read(&mut buffer).is_err() {
println!("Error checking is working");
}
f5 = open(f5).unwrap();
let f5_length = f5.read(&mut buffer).unwrap();
f5 = close(f5).unwrap();
let text = String::from_utf8_lossy(&buffer);
println!("{:?}", f5);
println!("{} is {} bytes long", &f5.name, f5_length);
println!("{}", text);
}
// cargo r -q
Error checking is working
File { name: "5.txt", data: [], state: Closed }
5.txt is 0 bytes long
3.6 trait
3.6.1 创建名为 read 的 trait
#![allow(unused_variables)] // <1>
#[derive(Debug)]
struct File; // <2>
trait Read { // <3>
fn read(
self: &Self,
save_to: &mut Vec<u8>,
) -> Result<usize, String>; // <4>
}
impl Read for File {
fn read(self: &File, save_to: &mut Vec<u8>) -> Result<usize, String> {
Ok(0) // <5>
}
}
fn main() {
let f = File{};
let mut buffer = vec!();
let n_bytes = f.read(&mut buffer).unwrap();
println!("{} byte(s) read from {:?}", n_bytes, f);
}
// cargo r -q
0 byte(s) read from File
3.6.2 为类型实现 std::fmt::Display
#![allow(dead_code)] // <1>
use std::fmt; // <2>
use std::fmt::{Display}; // <3>
#[derive(Debug, PartialEq)]
enum FileState {
Open,
Closed,
}
#[derive(Debug)]
struct File {
name: String,
data: Vec<u8>,
state: FileState,
}
impl Display for FileState {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
FileState::Open => write!(f, "OPEN"), // <4>
FileState::Closed => write!(f, "CLOSED"), // <4>
}
}
}
impl Display for File {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "<{} ({})>", self.name, self.state) // <5>
}
}
impl File {
fn new(name: &str) -> File {
File {
name: String::from(name),
data: Vec::new(),
state: FileState::Closed,
}
}
}
fn main() {
let f6 = File::new("f6.txt");
//...
println!("{:?}", f6); // <6>
println!("{}", f6); // <7>
}
// cargo r -q
File { name: "f6.txt", data: [], state: Closed }
<f6.txt (CLOSED)>
四、生命周期-所有权-借用
- 基本类型默认实现了 copy trait，则按如下正常运行：
#![allow(unused_variables)]
#[derive(Debug)]
enum StatusMessage {
Ok,
}
fn check_status(sat_id: u64) -> StatusMessage {
StatusMessage::Ok
}
fn main () {
let sat_a = 0; // <1>
let sat_b = 1; // <1>
let sat_c = 2; // <1>
let a_status = check_status(sat_a);
let b_status = check_status(sat_b);
let c_status = check_status(sat_c);
println!("a: {:?}, b: {:?}, c: {:?}", a_status, b_status, c_status);
// "waiting" ...
let a_status = check_status(sat_a);
let b_status = check_status(sat_b);
let c_status = check_status(sat_c);
println!("a: {:?}, b: {:?}, c: {:?}", a_status, b_status, c_status);
}
- 复合类型如 struct 默认未实现 copy trait，则不会正常运行：
#[derive(Debug)] // <1>
struct CubeSat {
id: u64,
}
#[derive(Debug)]
enum StatusMessage {
Ok,
}
fn check_status(
sat_id: CubeSat
) -> StatusMessage { // <2>
StatusMessage::Ok
}
fn main() {
let sat_a = CubeSat { id: 0 }; // <3>
let a_status = check_status(sat_a);
println!("a: {:?}", a_status);
// "waiting" ...
let a_status = check_status(sat_a);
println!("a: {:?}", a_status);
}
报错信息如下：
- 另一个例子如下：
fn use_value(_val: Demo) {}
struct Demo {
a: i32,
}
fn main() {
let demo = Demo {a: 123};
use_value(demo);
println!("{}", demo.a);
}
4.5 所有权
#[derive(Debug)]
struct CubeSat {
id: u64,
mailbox: Mailbox,
}
#[derive(Debug)]
struct Mailbox {
messages: Vec<Message>,
}
type Message = String;
struct GroundStation;
impl GroundStation {
fn send(&self, to: &mut CubeSat, msg: Message) {
to.mailbox.messages.push(msg);
}
}
impl CubeSat {
fn recv(&mut self) -> Option<Message> {
self.mailbox.messages.pop()
}
}
fn main() {
let base = GroundStation {};
let mut sat_a = CubeSat {
id: 0,
mailbox: Mailbox {
messages: vec![],
},
};
println!("t0: {:?}", sat_a);
base.send(&mut sat_a,
Message::from("hello there!")); // <1>
println!("t1: {:?}", sat_a);
let msg = sat_a.recv();
println!("t2: {:?}", sat_a);
println!("msg: {:?}", msg);
}
// cargo r
t0: CubeSat { id: 0, mailbox: Mailbox { messages: [] } }
t1: CubeSat { id: 0, mailbox: Mailbox { messages: ["hello there!"] } }
t2: CubeSat { id: 0, mailbox: Mailbox { messages: [] } }
4.5.2 引用
#![allow(unused_variables)]
#[derive(Debug)]
struct CubeSat {
id: u64,
}
#[derive(Debug)]
struct Mailbox {
messages: Vec<Message>,
}
#[derive(Debug)]
struct Message {
to: u64,
content: String,
}
struct GroundStation {}
impl Mailbox {
fn post(&mut self, msg: Message) {
self.messages.push(msg);
}
fn deliver(&mut self, recipient: &CubeSat) -> Option<Message> {
for i in 0..self.messages.len() {
if self.messages[i].to == recipient.id {
let msg = self.messages.remove(i);
return Some(msg);
}
}
None
}
}
impl GroundStation {
fn connect(&self, sat_id: u64) -> CubeSat {
CubeSat {
id: sat_id,
}
}
fn send(&self, mailbox: &mut Mailbox, msg: Message) {
mailbox.post(msg);
}
}
impl CubeSat {
fn recv(&self, mailbox: &mut Mailbox) -> Option<Message> {
mailbox.deliver(&self)
}
}
fn fetch_sat_ids() -> Vec<u64> {
vec![1,2,3]
}
fn main() {
let mut mail = Mailbox { messages: vec![] };
let base = GroundStation {};
let sat_ids = fetch_sat_ids();
for sat_id in sat_ids {
// let sat = base.connect(sat_id);
let msg = Message { to: sat_id, content: String::from("hello") };
base.send(&mut mail, msg);
}
let sat_ids = fetch_sat_ids();
for sat_id in sat_ids {
let sat = base.connect(sat_id);
let msg = sat.recv(&mut mail);
println!("{:?}: {:?}", sat, msg);
}
}
// cargo r
CubeSat { id: 1 }: Some(Message { to: 1, content: "hello" })
CubeSat { id: 2 }: Some(Message { to: 2, content: "hello" })
CubeSat { id: 3 }: Some(Message { to: 3, content: "hello" })
4.5.3 Copy 和 Clone
#[derive(Debug, Clone, Copy)] // <1>
struct CubeSat {
id: u64,
}
#[derive(Debug, Clone, Copy)] // <1>
enum StatusMessage {
Ok,
}
fn check_status(sat_id: CubeSat) -> StatusMessage {
StatusMessage::Ok
}
fn main () {
let sat_a = CubeSat { id: 0 };
let a_status = check_status(sat_a.clone()); // <2>
println!("a: {:?}", a_status.clone()); // <2>
let a_status = check_status(sat_a); // <3>
println!("a: {:?}", a_status); // <3>
}
// cargo r
a: Ok
a: Ok
五、深入理解数据
5.1 位模式和类型
如下例，同样的二进制位，若用不同的数据类型解释，则会有不同的值。
fn main() {
let a: u16 = 50115;
let b: i16 = -15421;
println!("a {:016b} {}", a, a);
println!("b {:016b} {}", b, b);
}
// 运行效果如下：
a 1100001111000011 50115
b 1100001111000011 -15421
下例更进一步说明：
fn main() {
let a: f32 = 42.42;
let frankentype: u32 = unsafe {
std::mem::transmute(a) // <1>
};
println!("{}", frankentype); // <2>
println!("{:032b}", frankentype); // <3>
let b: f32 = unsafe {
std::mem::transmute(frankentype)
};
println!("{}", b);
assert_eq!(a, b); // <4>
}
// 运行效果如下：
1110027796
01000010001010011010111000010100
42.42
5.2 整数的生存范围
每个类型都存在数据范围，如无符号16位整数是0~65535，若超过上限即为溢出。如下例
fn main() {
let mut i: u16 = 0;
println!("{}..", i);
loop {
i += 1000;
print!("{}..", i);
if i % 10000 == 0 {
print!("\n")
}
}
}
// 程序输出如下：
0..
1000..2000..3000..4000..5000..6000..7000..8000..9000..10000..
11000..12000..13000..14000..15000..16000..17000..18000..19000..20000..
21000..22000..23000..24000..25000..26000..27000..28000..29000..30000..
31000..32000..33000..34000..35000..36000..37000..38000..39000..40000..
41000..42000..43000..44000..45000..46000..47000..48000..49000..50000..
51000..52000..53000..54000..55000..56000..57000..58000..59000..60000..
thread 'main' panicked at 'attempt to add with overflow', src/main.rs:5:5
stack backtrace:
0: rust_begin_unwind
at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/std/src/panicking.rs:578:5
1: core::panicking::panic_fmt
at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/core/src/panicking.rs:67:14
2: core::panicking::panic
at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/core/src/panicking.rs:117:5
3: mandelbrot::main
at ./src/main.rs:5:5
4: core::ops::function::FnOnce::call_once
at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/core/src/ops/function.rs:250:5
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
61000..62000..63000..64000..65000..
下例展示了65535的上界：
fn main() {
let zero: u16 = 0b0000_0000_0000_0000;
let one: u16 = 0b0000_0000_0000_0001;
let two: u16 = 0b0000_0000_0000_0010;
// ...
let sixtyfivethousand_533: u16 = 0b1111_1111_1111_1101;
let sixtyfivethousand_534: u16 = 0b1111_1111_1111_1110;
let sixtyfivethousand_535: u16 = 0b1111_1111_1111_1111;
print!("{}, {}, {}, ..., ", zero, one, two);
println!("{}, {}, {}", sixtyfivethousand_533, sixtyfivethousand_534, sixtyfivethousand_535);
}
// code result:
0, 1, 2, ..., 65533, 65534, 65535
下例允许溢出，可观测到溢出效果：
#[allow(arithmetic_overflow)]
fn main() {
let (a, b) = (200, 200);
let c: u8 = a + b;
println!("200 + 200 = {}", c);
}
// code result:
thread 'main' panicked at 'attempt to add with overflow', src/main.rs:4:15
stack backtrace:
0: rust_begin_unwind
at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/std/src/panicking.rs:578:5
1: core::panicking::panic_fmt
at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/core/src/panicking.rs:67:14
2: core::panicking::panic
at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/core/src/panicking.rs:117:5
3: mandelbrot::main
at ./src/main.rs:4:15
4: core::ops::function::FnOnce::call_once
at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/core/src/ops/function.rs:250:5
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
通过上例，我们知道尽管 Rust 有很多优点，但 Rust 编写的程序仍有可能崩溃。
5.2.1 字节序
下例可知，同样的二进制位，用大端序 or 小端序解释，有不同的结果：
use std::mem::transmute;
fn main() {
let big_endian: [u8; 4] = [0xAA, 0xBB, 0xCC, 0xDD];
let little_endian: [u8; 4] = [0xDD, 0xCC, 0xBB, 0xAA];
let a: i32 = unsafe { transmute(big_endian) };
let b: i32 = unsafe { transmute(little_endian) };
println!("{} vs {}", a, b);
}
// code result:
-573785174 vs -1430532899
- 字节之间的布局：20世纪90年代，不同厂商有不同的字节序实现，Inter 选择的小端占了绝大部分市场。
- 字节内部的布局：称为 位编号（bit numbering）或 位端序（bit endianness），并不影响日常编程，可查自己的计算机平台的最高有效位（most significiant byte）究竟属于哪一端。
5.4 浮点数
浮点数，在计算机中，用科学计数法表示。科学计数法由符号（sign）、尾数（mantissa）、基数（radix）、指数（exponent）组成。
5.4.1 观察 f32 的内部
f32 类型的 42.42 编码后的位模式是 01000010001010011010111000010100，即 0x4229AE14，如下图所示：
5.4.2 分离出符号位
5.4.3 分离出指数
5.4.4 分离出尾数
5.4.5 剖析一个浮点数
const BIAS: i32 = 127; // <1>
const RADIX: f32 = 2.0; // <1>
fn main() { // <2>
let n: f32 = 42.42;
let (sign, exp, frac) = to_parts(n); // 0 132 2731540
let (sign_, exp_, mant) = decode(sign, exp, frac); // 1 32 1.32562494
let n_ = from_parts(sign_, exp_, mant); // 42.4199982
println!("{} -> {}", n, n_);
println!("field | as bits | as real number");
println!("sign | {:01b} | {}", sign, sign_);
println!("exponent | {:08b} | {}", exp, exp_);
println!("mantissa | {:023b} | {}", frac, mant);
}
fn to_parts(n: f32) -> (u32, u32, u32) {
let bits = n.to_bits();
let sign = (bits >> 31) & 1; // 使用移位操作移除不需要的31个位数据，只保留符号位
let exponent = (bits >> 23) & 0xff; // 先移除23个不需要的位数据，然后使用逻辑与掩码操作过滤高位的数据
let fraction = bits & 0x7fffff ; // 使用一个与掩码操作，只保留23个最低有效位
(sign, exponent, fraction) // 尾数部分在这里叫作fraction（分数），执行了解码操作后，才管这部分数据叫作尾数
}
fn decode(
sign: u32,
exponent: u32,
fraction: u32
) -> (f32, f32, f32) {
let signed_1 = (-1.0_f32).powf(sign as f32); // 把符号位转换成1.0或者-1.0。在这里，−1.0_f32需要用括号括起来，用于表明运算的优先级，这是因为方法调用的优先级高于单目减号运算符的
let exponent = (exponent as i32) - BIAS; // 指数必须先转为i32，因为减去BIAS以后的结果有可能是负数。接下来，还需要把它转换为f32，这样才能把它用于指数幂的运算中
let exponent = RADIX.powf(exponent as f32); // <8>
let mut mantissa: f32 = 1.0;
for i in 0..23 { // 用5.4.4节中描述的逻辑来解码尾数
let mask = 1 << i; // <9>
let one_at_bit_i = fraction & mask; // <9>
if one_at_bit_i != 0 { // <9>
let i_ = i as f32; // <9>
let weight = 2_f32.powf( i_ - 23.0 ); // <9>
mantissa += weight; / ·/ <9>
} // <9>
} // <9>
(signed_1, exponent, mantissa)
}
fn from_parts( // 在中间步骤中直接使用了f32的值，有一些“作弊”的意思。希望这个“作弊”行为是可以被原谅的
sign: f32,
exponent: f32,
mantissa: f32,
) -> f32 {
sign * exponent * mantissa
}
// code result:
42.42 -> 42.42
field | as bits | as real number
sign | 0 | 1
exponent | 10000100 | 32
mantissa | 01010011010111000010100 | 1.325625
5.5 定点数格式
#[derive(Debug,Clone,Copy,PartialEq,Eq)]
pub struct Q7(i8);
impl From<f64> for Q7 {
fn from (n: f64) -> Self {
if n >= 1.0 {
Q7(127)
} else if n <= -1.0 {
Q7(-128)
} else {
Q7((n * 128.0) as i8)
}
}
}
impl From<Q7> for f64 {
fn from(n: Q7) -> f64 {
(n.0 as f64) * 2f64.powf(-7.0)
}
}
impl From<f32> for Q7 {
fn from (n: f32) -> Self {
Q7::from(n as f64)
}
}
impl From<Q7> for f32 {
fn from(n: Q7) -> f32 {
f64::from(n) as f32
}
}
#[cfg(test)]
mod tests { // <1>
use super::*; // <2>
#[test]
fn out_of_bounds() {
assert_eq!(Q7::from(10.), Q7::from(1.));
assert_eq!(Q7::from(-10.), Q7::from(-1.));
}
#[test]
fn f32_to_q7() {
let n1: f32 = 0.7;
let q1 = Q7::from(n1);
let n2 = -0.4;
let q2 = Q7::from(n2);
let n3 = 123.0;
let q3 = Q7::from(n3);
assert_eq!(q1, Q7(89));
assert_eq!(q2, Q7(-51));
assert_eq!(q3, Q7(127));
}
#[test]
fn q7_to_f32() {
let q1 = Q7::from(0.7);
let n1 = f32::from(q1);
assert_eq!(n1, 0.6953125);
let q2 = Q7::from(n1);
let n2 = f32::from(q2);
assert_eq!(n1, n2);
}
}
// code result:
running 3 tests
test tests::f32_to_q7 ... ok
test tests::out_of_bounds ... ok
test tests::q7_to_f32 ... ok
test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
5.6 从随机字节中生成随机概率
fn mock_rand(n: u8) -> f32 {
let base: u32 = 0b0_01111110_00000000000000000000000;
let large_n = (n as u32) << 15;
let f32_bits = base | large_n;
let m = f32::from_bits(f32_bits);
2.0 * ( m - 0.5 )
}
fn main() {
println!("max of input range: {:08b} -> {:?}", 0xff, mock_rand(0xff));
println!("mid of input range: {:08b} -> {:?}", 0x7f, mock_rand(0x7f));
println!("min of input range: {:08b} -> {:?}", 0x00, mock_rand(0x00));
}
// code result:
max of input range: 11111111 -> 0.99609375
mid of input range: 01111111 -> 0.49609375
min of input range: 00000000 -> 0.0
5.7 实现一个 CPU 模拟器
我们可以通过程序，模拟 CPU 的工作方式，了解计算机如何在基础层面运行的。我们将实现一个 CHIP-8 系统的子集。
5.7.1 CPU 原型1：加法器
CPU 需要把数据从内存加载到寄存器，并和 操作码 做运算。
struct CPU {
current_operation: u16,
registers: [u8; 2],
}
impl CPU {
fn read_opcode(&self) -> u16 {
self.current_operation // 如果引入了从内存中读取的功能，read_opcode() 会变得更复杂
}
fn run(&mut self) {
// loop {
let opcode = self.read_opcode(); // 0x8014即32788
// 操作码的解码过程
let c = ((opcode & 0xF000) >> 12) as u8; // 8
let x = ((opcode & 0x0F00) >> 8) as u8; // 0
let y = ((opcode & 0x00F0) >> 4) as u8; // 1
let d = ((opcode & 0x000F) >> 0) as u8; // 4
match (c, x, y, d) {
(0x8, _, _, 0x4) => self.add_xy(x, y), // 把真正执行此操作的任务，分配到负责执行该操作的“硬件电路”上
_ => todo!("opcode {:04x}", opcode), // 一个全功能的模拟器，包含许多不同的操作任务
}
// }
}
fn add_xy(&mut self, x: u8, y: u8) {
self.registers[x as usize] += self.registers[y as usize];
}
}
fn main() {
let mut cpu = CPU {
current_operation: 0,
registers: [0; 2],
};
cpu.current_operation = 0x8014;
cpu.registers[0] = 5;
cpu.registers[1] = 10;
cpu.run();
assert_eq!(cpu.registers[0], 15);
println!("5 + 10 = {}", cpu.registers[0]);
}
// code result:
5 + 10 = 15
CHIP-8 操作码各组成部分如下图：
操作码解码过程如下：
fn main() {
let opcode: u16 = 0x71E4;
let c = (opcode & 0xF000) >> 12; // 先使用与（&）操作进行过滤，把想要的那个半字节保留下来，然后把这个半字节的位数据右移位到最低有效位的位置上。使用十六进制表示只是出于方便，每个十六进制的数字位表示二进制的4个位。一个0xF的值就选中了单个半字节所有的位数据。
let x = (opcode & 0x0F00) >> 8;
let y = (opcode & 0x00F0) >> 4;
let d = (opcode & 0x000F) >> 0;
assert_eq!(c, 0x7); // opcode中的这4个半字节，在处理以后会拆分出4个独立的变量。
assert_eq!(x, 0x1);
assert_eq!(y, 0xE);
assert_eq!(d, 0x4);
let nnn = opcode & 0x0FFF; // 若想要多个半字节，可以通过增加过滤器的宽度来一次性选中更多的半字节。为此，在这里向右移位就不是必需的了。
let kk = opcode & 0x00FF;
assert_eq!(nnn, 0x1E4);
assert_eq!(kk, 0xE4);
}
5.7.3 CPU 原型2：累加器
5.7.3.1 使 CPU 支持内存访问
计算机是需要内存的，代码如下：
struct CPU {
registers: [u8; 16],
position_in_memory: usize, // 用usize而不是u16与最初的规范是不同的，但我们用usize，因为Rust允许此类型被用于索引。
memory: [u8; 0x1000],
}
5.7.3.2 从内存中读取操作码
从内存读出两个 u8，并合并为一个 u16。
fn read_opcode(&self) -> u16 {
let p = self.position_in_memory;
let op_byte1 = self.memory[p] as u16;
let op_byte2 = self.memory[p + 1] as u16;
op_byte1 << 8 | op_byte2 // 要创建一个u16类型的操作码，我们使用逻辑或操作，把内存中的两个值合并到一起。这两个值需要先转换为u16，如果不先做这个转换，左移位会将所有的位数据都设为0。
}
5.7.3.3 处理整数溢出
CHIP-8 中，最后一个寄存器被用作 进位标志，若其被设置，说明有一个操作在 u8 大小的寄存器中产生了溢出。
fn add_xy(&mut self, x: u8, y: u8) {
let arg1 = self.registers[x as usize];
let arg2 = self.registers[y as usize];
let (val, overflow) = arg1.overflowing_add(arg2); ⇽---- 对于u8类型来说，overflowing_add() 方法的返回类型为 (u8, bool)。如果检测到溢出则返回值中这个布尔类型的值为true。
self.registers[x as usize] = val;
if overflow {
self.registers[0xF] = 1;
} else {
self.registers[0xF] = 0;
}
}
5.7.3.4 完整代码
struct CPU {
registers: [u8; 16],
position_in_memory: usize,
memory: [u8; 0x1000],
}
impl CPU {
fn read_opcode(&self) -> u16 {
let p = self.position_in_memory;
let op_byte1 = self.memory[p] as u16;
let op_byte2 = self.memory[p + 1] as u16;
op_byte1 << 8 | op_byte2
}
fn run(&mut self) {
loop { // <1>
let opcode = self.read_opcode();
self.position_in_memory += 2; // 自增position_in_memory，指向下一条指令
let c = ((opcode & 0xF000) >> 12) as u8;
let x = ((opcode & 0x0F00) >> 8) as u8;
let y = ((opcode & 0x00F0) >> 4) as u8;
let d = ((opcode & 0x000F) >> 0) as u8;
match (c, x, y, d) {
(0, 0, 0, 0) => { return; }, // 当遇到的操作码为0x0000时，此处的短路功能会终止函数的执行
(0x8, _, _, 0x4) => self.add_xy(x, y),
_ => todo!("opcode {:04x}", opcode),
}
}
}
fn add_xy(&mut self, x: u8, y: u8) {
let arg1 = self.registers[x as usize];
let arg2 = self.registers[y as usize];
let (val, overflow) = arg1.overflowing_add(arg2);
self.registers[x as usize] = val;
if overflow {
self.registers[0xF] = 1;
} else {
self.registers[0xF] = 0;
}
}
}
fn main() {
let mut cpu = CPU {
registers: [0; 16],
memory: [0; 4096],
position_in_memory: 0,
};
cpu.registers[0] = 5;
cpu.registers[1] = 10;
cpu.registers[2] = 10; // 使用值来初始化几个寄存器
cpu.registers[3] = 10; // <4>
let mem = &mut cpu.memory;
mem[0] = 0x80; mem[1] = 0x14; // 加载操作码0x8014，0x8014的意思是把寄存器1的值加到寄存器0上
mem[2] = 0x80; mem[3] = 0x24; // 加载操作码0x8024，0x8024的意思是把寄存器2的值加到寄存器0上
mem[4] = 0x80; mem[5] = 0x34; // 加载操作码0x8034，0x8034的意思是把寄存器3的值加到寄存器0上
cpu.run();
assert_eq!(cpu.registers[0], 35);
println!("5 + 10 + 10 + 10 = {}", cpu.registers[0]);
}
// code result:
5 + 10 + 10 + 10 = 35
5.7.4 CPU 原型3：调用函数
我们几乎快要构建完成模拟器的全部机制了，本节增加调用函数的能力。
5.7.4.1 给 CPU 扩展出 支持栈 的能力
struct CPU {
registers: [u8; 16],
position_in_memory: usize,
memory: [u8; 4096],
stack: [u16; 16], // 栈的最大高度是16。在16次嵌套的函数调用后，此程序将会发生栈溢出。
stack_pointer: usize, // 把stack_pointer（栈指针）的类型设为usize，可以让在stack（栈）中索引值的操作变得更容易。
}
5.7.4.2 定义一个函数并把它加载到内存中
fn main() {
let mut memory: [u8; 4096] = [0; 4096];
let mem = &mut memory;
mem[0x100] = 0x80; mem[0x101] = 0x14;
mem[0x102] = 0x80; mem[0x103] = 0x14;
mem[0x104] = 0x00; mem[0x105] = 0xEE;
println!("{:?}", &mem[0x100..0x106]); // 输出[128, 20, 128, 20, 0, 238]。
}
5.7.4.3 实现 CALL 和 RETURN 操作码
fn call(&mut self, addr: u16) {
let sp = self.stack_pointer;
let stack = &mut self.stack;
if sp > stack.len() {
panic!("Stack overflow!")
}
stack[sp] = self.position_in_memory as u16; // 把当前position_in_memory的值加入栈。此内存地址比调用位置高两个字节，因为它已在run()方法的方法体中执行了自增。
self.stack_pointer += 1; // 自增self.stack_pointer。这个操作能防止在栈中已保存的self.position_in_memory被覆盖，在后面函数返回时还需要用到这个值。
self.position_in_memory = addr as usize; // 修改self.position_in_ memory的值，其作用是跳转到修改后的地址。
}
fn ret(&mut self) {
if self.stack_pointer == 0 {
panic!("Stack underflow");
}
self.stack_pointer -= 1;
let call_addr = self.stack[self.stack_pointer]; // 跳转到调用之前的地址，也就是在前面函数调用时保存的那个地址。
self.position_in_memory = call_addr as usize;
}
5.7.4.4 完整代码
struct CPU {
registers: [u8; 16],
position_in_memory: usize,
memory: [u8; 4096],
stack: [u16; 16],
stack_pointer: usize,
}
impl CPU {
fn read_opcode(&self) -> u16 {
let p = self.position_in_memory;
let op_byte1 = self.memory[p] as u16;
let op_byte2 = self.memory[p + 1] as u16;
op_byte1 << 8 | op_byte2
}
fn run(&mut self) {
loop {
let opcode = self.read_opcode();
self.position_in_memory += 2;
let c = ((opcode & 0xF000) >> 12) as u8;
let x = ((opcode & 0x0F00) >> 8) as u8;
let y = ((opcode & 0x00F0) >> 4) as u8;
let d = ((opcode & 0x000F) >> 0) as u8;
let nnn = opcode & 0x0FFF;
// let kk = (opcode & 0x00FF) as u8;
match (c, x, y, d) {
( 0, 0, 0, 0) => { return; },
( 0, 0, 0xE, 0xE) => self.ret(),
(0x2, _, _, _) => self.call(nnn),
(0x8, _, _, 0x4) => self.add_xy(x, y),
_ => todo!("opcode {:04x}", opcode),
}
}
}
fn call(&mut self, addr: u16) {
let sp = self.stack_pointer;
let stack = &mut self.stack;
if sp >= stack.len() {
panic!("Stack overflow!")
}
stack[sp] = self.position_in_memory as u16;
self.stack_pointer += 1;
self.position_in_memory = addr as usize;
}
fn ret(&mut self) {
if self.stack_pointer == 0 {
panic!("Stack underflow");
}
self.stack_pointer -= 1;
let addr = self.stack[self.stack_pointer];
self.position_in_memory = addr as usize;
}
fn add_xy(&mut self, x: u8, y: u8) {
let arg1 = self.registers[x as usize];
let arg2 = self.registers[y as usize];
let (val, overflow_detected) = arg1.overflowing_add(arg2);
self.registers[x as usize] = val;
if overflow_detected {
self.registers[0xF] = 1;
} else {
self.registers[0xF] = 0;
}
}
}
fn main() {
let mut cpu = CPU {
registers: [0; 16],
memory: [0; 4096],
position_in_memory: 0,
stack: [0; 16],
stack_pointer: 0,
};
cpu.registers[0] = 5;
cpu.registers[1] = 10;
let mem = &mut cpu.memory;
mem[0x000] = 0x21; mem[0x001] = 0x00; // 设置操作码0x2100：在0x100处调用函数
mem[0x002] = 0x21; mem[0x003] = 0x00; // 设置操作码0x2100：同样是在0x100处调用函数
mem[0x004] = 0x00; mem[0x005] = 0x00; // 设置操作码0x0000：停止执行（严格意义上并非是必要的，因为cpu.memory是用空字节初始化的）
mem[0x100] = 0x80; mem[0x101] = 0x14; // 设置操作码0x8014：把寄存器1的值加到寄存器0上
mem[0x102] = 0x80; mem[0x103] = 0x14; // 设置操作码0x8014：把寄存器1的值加到寄存器0上
mem[0x104] = 0x00; mem[0x105] = 0xEE; // 设置操作码0x00EE：函数返回
cpu.run();
assert_eq!(cpu.registers[0], 45);
println!("5 + (10 * 2) + (10 * 2) = {}", cpu.registers[0]);
}
// code result:
5 + (10 * 2) + (10 * 2) = 45
下图展示了当运行 cpu.run() 时，CPU 内部发生了什么，其中箭头反映了执行程序时 cpu.position_in_memory 的状态变化：
如果你研究此系统的原始文档，就会发现比起简单跳转到一个预定义的内存位置，真实的函数要更复杂。不同的操作系统和CPU体系结构，在函数调用的约定以及函数的具体能力方面会有所不同。有的约定会要求把操作数加入栈，而有的则会要求把操作数插入已定义的寄存器。尽管某个特定系统的机制可能会有所不同，然而大致的过程与你刚刚看到过的这个过程是类似的。
5.7.5 CPU4：添加额外功能
额外的操作码实现如下：
struct CPU {
registers: [u8; 16],
position_in_memory: usize, // program counter ("PC")
memory: [u8; 4096],
stack: [u16; 16],
stack_pointer: usize,
}
impl CPU {
fn run(&mut self) {
loop {
let op_byte1 = self.memory[self.position_in_memory] as u16;
let op_byte2 = self.memory[self.position_in_memory + 1] as u16;
let opcode: u16 = op_byte1 << 8 | op_byte2;
let x = ((opcode & 0x0F00) >> 8) as u8;
let y = ((opcode & 0x00F0) >> 4) as u8;
// let n = ((opcode & 0x000F) >> 4) as u8;
let kk = (opcode & 0x00FF) as u8;
let op_minor = (opcode & 0x000F) as u8;
let addr = opcode & 0x0FFF;
self.position_in_memory += 2;
match opcode {
0x0000 => {
return;
}
0x00E0 => { /* CLEAR SCREEN */ }
0x00EE => {
self.ret();
}
0x1000..=0x1FFF => {
self.jmp(addr);
}
0x2000..=0x2FFF => {
self.call(addr);
}
0x3000..=0x3FFF => {
self.se(x, kk);
}
0x4000..=0x4FFF => {
self.sne(x, kk);
}
0x5000..=0x5FFF => {
self.se(x, y);
}
0x6000..=0x6FFF => {
self.ld(x, kk);
}
0x7000..=0x7FFF => {
self.add(x, kk);
}
0x8000..=0x8FFF => match op_minor {
0 => self.ld(x, self.registers[y as usize]),
1 => self.or_xy(x, y),
2 => self.and_xy(x, y),
3 => self.xor_xy(x, y),
4 => {
self.add_xy(x, y);
}
_ => {
todo!("opcode: {:04x}", opcode);
}
},
_ => todo!("opcode {:04x}", opcode),
}
}
}
/// (6xkk) LD sets the value `kk` into register `vx`
fn ld(&mut self, vx: u8, kk: u8) {
self.registers[vx as usize] = kk;
}
/// (7xkk) Add sets the value `kk` into register `vx`
fn add(&mut self, vx: u8, kk: u8) {
self.registers[vx as usize] += kk;
}
fn se(&mut self, vx: u8, kk: u8) {
if vx == kk {
self.position_in_memory += 2;
}
}
/// () SNE **S**tore if **n**ot **e**qual
fn sne(&mut self, vx: u8, kk: u8) {
if vx != kk {
self.position_in_memory += 2;
}
}
/// (1nnn) JUMP to `addr`
fn jmp(&mut self, addr: u16) {
self.position_in_memory = addr as usize;
}
/// (2nnn) CALL sub-routine at `addr`
fn call(&mut self, addr: u16) {
let sp = self.stack_pointer;
let stack = &mut self.stack;
if sp >= stack.len() {
panic!("Stack overflow!")
}
stack[sp] = self.position_in_memory as u16;
self.stack_pointer += 1;
self.position_in_memory = addr as usize;
}
/// (00ee) RET return from the current sub-routine
fn ret(&mut self) {
if self.stack_pointer == 0 {
panic!("Stack underflow");
}
self.stack_pointer -= 1;
self.position_in_memory = self.stack[self.stack_pointer] as usize;
}
// (7xkk)
fn add_xy(&mut self, x: u8, y: u8) {
self.registers[x as usize] += self.registers[y as usize];
// TODO: SET CARRY FLAG!!!!
}
fn and_xy(&mut self, x: u8, y: u8) {
let x_ = self.registers[x as usize];
let y_ = self.registers[y as usize];
self.registers[x as usize] = x_ & y_;
}
fn or_xy(&mut self, x: u8, y: u8) {
let x_ = self.registers[x as usize];
let y_ = self.registers[y as usize];
self.registers[x as usize] = x_ | y_;
}
fn xor_xy(&mut self, x: u8, y: u8) {
let x_ = self.registers[x as usize];
let y_ = self.registers[y as usize];
self.registers[x as usize] = x_ ^ y_;
}
}
fn main() {
let mut cpu = CPU {
registers: [0; 16],
memory: [0; 4096],
position_in_memory: 0,
stack: [0; 16],
stack_pointer: 0,
};
cpu.registers[0] = 5;
cpu.registers[1] = 10;
//
cpu.memory[0x000] = 0x21;
cpu.memory[0x001] = 0x00;
cpu.memory[0x002] = 0x21;
cpu.memory[0x003] = 0x00;
cpu.memory[0x100] = 0x80;
cpu.memory[0x101] = 0x14;
cpu.memory[0x102] = 0x80;
cpu.memory[0x103] = 0x14;
cpu.memory[0x104] = 0x00;
cpu.memory[0x105] = 0xEE;
cpu.run();
assert_eq!(cpu.registers[0], 45);
println!("5 + (10 * 2) + (10 * 2) = {}", cpu.registers[0]);
}
// code result:
5 + (10 * 2) + (10 * 2) = 45
学习有关CPU和数据的最后一步是了解控制流的工作方式。在CHIP-8中，控制流的工作方式是比较寄存器中的值，然后依据结果的不同来修改 position_in_memory的值。在CPU里是没有 while 循环或 for 循环的，在编程语言中创建出这些控制流的机制是编译器开发者的艺术。
六、内存
6.2 指针
static B: [u8; 10] = [99, 97, 114, 114, 121, 116, 111, 119, 101, 108];
static C: [u8; 11] = [116, 104, 97, 110, 107, 115, 102, 105, 115, 104, 0];
fn main() {
let a = 42;
let b = &B;
let c = &C;
println!("a: {}, b: {:p}, c: {:p}", a, b, c);
}
另一段代码如下：
use std::mem::size_of;
static B: [u8; 10] = [99, 97, 114, 114, 121, 116, 111, 119, 101, 108];
static C: [u8; 11] = [116, 104, 97, 110, 107, 115, 102, 105, 115, 104, 0];
fn main() {
let a: usize = 42; // usize的实际大小就是内存地址的宽度，而内存地址的宽度取决于编译代码时使用的CPU。所以此CPU又叫作编译目标。
let b: &[u8; 10] = &B;// &[u8; 10]读作“一个10字节的数组的引用”。此数组存放在内存的静态区域中，而该引用本身（一个宽度为usize字节的指针）是存放在栈上的。
let c: Box<[u8]> = Box::new(C); // Box<[u8]>类型是一个装箱的字节切片。当程序员把某个值装入一个箱子（box）中后，该值的所有权就被转移给了箱子的所有者。
println!("a (an unsigned integer):");
println!(" location: {:p}", &a);
println!(" size: {:?} bytes", size_of::<usize>());
println!(" value: {:?}", a);
println!();
println!("b (a reference to B):");
println!(" location: {:p}", &b);
println!(" size: {:?} bytes", size_of::<&[u8; 10]>());
println!(" points to: {:p}", b);
println!();
println!("c (a box for C):");
println!(" location: {:p}", &c);
println!(" size: {:?} bytes", size_of::<Box<[u8]>>());
println!(" points to: {:p}", c);
println!();
println!("B (an array of 10 bytes):");
println!(" location: {:p}", &B);
println!(" size: {:?} bytes", size_of::<[u8; 10]>());
println!(" value: {:?}", B);
println!();
println!("C (an array of 11 bytes):");
println!(" location: {:p}", &C);
println!(" size: {:?} bytes", size_of::<[u8; 11]>());
println!(" value: {:?}", C);
}
// cargo r
a (an unsigned integer):
location: 0x16d121a48
size: 8 bytes
value: 42
b (a reference to B):
location: 0x16d121a50
size: 8 bytes
points to: 0x102d14dbd
c (a box for C):
location: 0x16d121a58
size: 16 bytes
points to: 0x125606a10
B (an array of 10 bytes):
location: 0x102d14dbd
size: 10 bytes
value: [99, 97, 114, 114, 121, 116, 111, 119, 101, 108]
C (an array of 11 bytes):
location: 0x102d14dc7
size: 11 bytes
value: [116, 104, 97, 110, 107, 115, 102, 105, 115, 104, 0]
CStr 是 Rust 标准库（std）中的一个类型，其完整名称是 std::ffi::CStr。这个类型提供了对以 null 结尾的 C 字符串的表示，通常用在与 C 代码交互时。CStr 类型确保了字符串是以 C 风格的方式结束的（即以 null 字符 \0 结尾），这使得它可以安全地传递到期望 C 字符串的 C API。
CStr 是不可变的，所以你不能修改其中的内容。要创建一个 CStr，你通常需要一个已存在的 C 字符串或者一个 Rust 字符串切片，并使用 CStr::from_bytes_with_nul 或 CStr::from_ptr 方法来创建。因为它代表了一个外部的、可能不受 Rust 所有权规则管理的字符串，所以它不拥有其内容的所有权。
下文是智能指针 Cow 的用法：
use std::borrow::Cow; // 一种智能指针类型，能够从其指针位置读取数据而无须先复制它。
use std::ffi::CStr; // CStr是一个类似于C字符串的类型，它让Rust能够读取以0作为结束标志的字符串。
use std::os::raw::c_char; // c_char是Rust中i8类型的别名，但对于特定的平台，它可能会存在一些细微的差别。
static B: [u8; 10] = [99, 97, 114, 114, 121, 116, 111, 119, 101, 108];
static C: [u8; 11] = [116, 104, 97, 110, 107, 115, 102, 105, 115, 104, 0];
fn main() {
let a = 42; // 在这里引入了每个变量，在后面的println! 中才能够访问到。假如把创建b和c的两行代码放到下面的unsafe块中，那么在后面超出了作用域后，输出语句那里就访问不到了。
let b: String; // String是一种智能指针类型。它包含一个指向后端数组的指针和一个用于存储其大小的字段。
let c: Cow<str>; // Cow接收一个类型参数，即它所指向的数据类型。str是CStr.to_string_lossy() 的返回类型，所以放在这里是合适的。
unsafe {
let b_ptr = &B as *const u8 as *mut u8; // 引用不能直接转换为*mut T，而后者正是String::from_raw_parts()所需要的类型。但是，*const T可以转换为*mut T，所以就有了这个二次类型转换的语法。
b = String::from_raw_parts(b_ptr, 10, 10); // String::from_raw_parts()接收3个参数，一个参数是指向字节数组的指针（*mut T），另两个是大小和容量参数。
let c_ptr = &C as *const u8 as *const c_char; // 我们把一个*const u8转换为*const i8，后者就是c_char的别名。在这里，转换到i8之所以能够成功，是因为依据ASCII标准，数据一定都是小于128的。
c = CStr::from_ptr(c_ptr).to_string_lossy(); // 从概念上讲，CStr::from_ptr()负责读取指针指向的数据，直到遇到0为止，然后利用读取到的结果数据生成一个Cow<str>。
println!("a: {}, b: {}, c: {}", a, b, c);
}
}
// cargo r
a: 42, b: carrytowel, c: thanksfish
my-project(34882,0x1e676db40) malloc: *** error for object 0x1020c319c: pointer being freed was not allocated
my-project(34882,0x1e676db40) malloc: *** set a breakpoint in malloc_error_break to debug
[1] 34882 abort cargo r
6.2.1 原始指针
原始指针是不安全的（因为可为 NULL），其有两种：* const T 和 * mut T，彼此可自由转换。
引用（& mut T 和 &T）会被向下编译为原始指针，即不需通过 unsafe 块即可获得原始指针的性能。
fn main() {
let a: i64 = 42;
let a_ptr = &a as *const i64; // 将a的引用(&a) 转换为 指向i64的常量原始指针(*const i64)
println!("a: {} ({:p})", a, a_ptr); // 输出a的值(42)以及它在内存中的地址
}
// cargo r
a: 42 (0x7fff07f217c8)
【指针】和【内存地址】有时可互换使用：
- 共同点：都是整数，用于表示虚拟内存中的位置。
- 不同点：
- 指针：总是指向 T 的起始字节，且其知道 T 类型的字节宽度。
- 内存地址：可引用内存中的任意位置。
一个 i64 是 8 bytes（64 bit，即(64/8) bytes），代码如下：
fn main() {
let a: i64 = 42;
let a_ptr = &a as *const i64;
let a_addr: usize = unsafe {
std::mem::transmute(a_ptr) // 把*const i64解释为usize类型。使用transmute()是非常不安全的，但是这让我们可以暂缓引入更多的语法。
};
println!("a: {} ({:p}...0x{:x})", a, a_ptr, a_addr + 7);
}
// cargo r
a: 42 (0x7ffd5693e388...0x7ffd5693e38f)
从底层实现上来看，引用（&T 和 &mut T）是被实现为原始指针的，但是引用有额外的保证，故应被优先考虑使用。
下文展示了原始指针的不稳定性：
fn main() {
let ptr = 42 as *const Vec<String>; // 你可以安全地从任何整数值中创建出指针。很显然，一个i32不是一个Vec<String>，但在这里，Rust很乐意忽略这一点。
unsafe {
let new_addr = ptr.offset(4);
println!("{:p} -> {:p}", ptr, new_addr);
}
}
// cargo r
0x2a -> 0x8a
6.2.2 Rust 指针的生态系统
英文版如下：
中文版如下：
6.2.3 智能指针块构建
6.3 为程序提供存储数据的内存
6.3.1 栈
6.3.2 堆
use std::mem::drop; // 手动导入drop() 到局部作用域。
fn main() {
let a = Box::new(1); // 在堆上分配值。
let b = Box::new(1);
let c = Box::new(1);
let result1 = *a + *b + *c; // 单目操作符*叫作解引用操作符，它会返回箱子里面的值，result1的值为3。
drop(a); // 调用drop()，会释放出这部分内存，以便留作他用。
let d = Box::new(1);
let result2 = *b + *c + *d;
println!("{} {}", result1, result2);
}
// cargo r
3 3
上述代码的内存布局如下图所示：
- 其中【栈上的变量 a】其实是一个指向 Box 的指针，其占 64 bit（因为现在大多数人的电脑都是 64 bit的）即 8Bytes。而 8 Bytes（十进制） = 0x08(十六进制)。
- 则若 变量 a 的地址为 0xFFF，且 指针 a 指向的【堆上 A】的地址是 0x100。的话
- 则【栈上的变量 b】的地址是 0xFFF - 0x008 = 0xFF7。且 指针 b 指向的【堆上 B】的地址是 0x100 + 0x008 = 0x108。
- 则【栈上的变量 c】的地址是 0xFF7 - 0x008 = 0xFEF。且 指针 c 指向的【堆上 C】的地址是 0x108 + 0x008 = 0x110。
- 则【栈上的变量 result1】的地址是 0xFEF - 0x008 = 0xFE7。且 变量 result1 的值为 3。
- drop(a) 会标记栈上的 a 无效，并标记堆上的 A 无效。即变量a 的生命周期在此时结束。
- 则【栈上的变量 d】的地址是 0xFE7- 0x008 = 0xFDF。【堆上 d】的地址是重用了 【原堆上 a 的地址 0x100】。
- PS：下图左下角的地址空间范围推导过程为：因下图中最大地址是 0xFFF，故地址空间是 0xFFF - 0x000 + 1(B) = 0xF000 = 15 * 16 ^ 3 = 4096 Bytes。
6.3.3 分析【堆】分配动态内存的速度
cd ch6/ch6-particles && cargo run 运行下述代码，得到如下效果：
6.4 虚拟内存
6.4.2 第一步：让一个进程扫描它自己的内存
从直观上来说，一个程序的内存就是一系列的字节，从O的位置开始到n的位置结束。如果一个程序使用了100 KB的RAM，那么n的值大概是100000。接下来，让我们使用示例来进行测试。
我们会创建一个小命令行程序来查看内存，开始位置为0，结束位置为10000。因为这是个很小的程序,所以它占用的内存不会超过10000字节。下面给出的这个示例程序，并不会如预期那样去执行，而会崩溃。学完本节内容后，你就会知道这个程序为什么会发生崩溃了。
fn main() {
let mut n_nonzero = 0;
for i in 0..10000 {
let ptr = i as *const u8; // 把i转换为 *const T类型，一个u8类型的原始指针。原始指针允许程序员去查看原始内存地址。在这里，我们把每个地址视为一个单元，而不考虑实际上大部分的值都是跨越多个字节的。
let byte_at_addr = unsafe { *ptr }; // 解引用指针，也就是读取地址i处的值。另一种说法是“读取此指针所指向的值”。
if byte_at_addr != 0 {
n_nonzero += 1;
}
}
println!("non-zero bytes in memory: {}", n_nonzero);
}
// code result:
segmentation fault
清单6.12所示程序崩溃的原因是试图去解引用一个 NULL(空）指针。当 i 的值等于 0 时，ptr 根本不可能解引用成功。顺便说一下，这也是所有原始指针解引用的操作必须放在 unsafe 块中的原因。然而 for i in 1…10000 还是会引发 segmentation fault 的错误。
static GLOBAL: i32 = 1000; // <1>
fn noop() -> *const i32 {
let noop_local = 12345; // <2>
&noop_local as *const i32 // <3>
}
fn main() {
let local_str = "a"; // <4>
let local_int = 123; // <4>
let boxed_str = Box::new('b'); // <4>
let boxed_int = Box::new(789); // <4>
let fn_int = noop(); // <4>
println!("GLOBAL: {:p}", &GLOBAL as *const i32);
println!("local_str: {:p}", local_str as *const str);
println!("local_int: {:p}", &local_int as *const i32);
println!("boxed_int: {:p}", Box::into_raw(boxed_int));
println!("boxed_str: {:p}", Box::into_raw(boxed_str));
println!("fn_int: {:p}", fn_int);
}
// code result:
GLOBAL: 0x7ff6d6ec9310
local_str: 0x7ff6d6ec9314
local_int: 0x23d492f91c
boxed_int: 0x18361b78320
boxed_str: 0x18361b78070
fn_int: 0x23d492f8ec
6.4.3 把虚拟地址 翻译为 物理地址
6.4.4 第二步：通过操作系统来扫描地址空间
在 windows 上安装 rust，cargo new ch6-meminfo-win 新建项目，设置 Cargo.toml 如下：
[package]
name = "meminfo"
version = "0.1.0"
authors = ["Tim McNamara <author@rustinaction.com>"]
edition = "2018"
[dependencies]
winapi = "0.2" # 定义了一些有用的类型别名。
kernel32-sys = "0.2" # 提供了使用KERNEL.DLL来与Windows API进行交互的功能。
main.rs 如下：
use kernel32;
use winapi;
use winapi::{
DWORD, // 在Rust里，这个类型叫作u32。
HANDLE, // 多个内部API使用的没有关联类型的指针类型（可以接收任何类型的指针）。在Rust里，std::os::raw::c_void定义了void指针。一个HANDLE（句柄）是在Windows中指向一些不透明资源的指针。
LPVOID,
PVOID, // 在Windows里，数据类型的名称常常会用一个前缀代表类型的缩写。P代表指针，LP代表长指针（例如64位的指针）。
SIZE_T, //
LPSYSTEM_INFO, // 指向一个SYSTEM_INFO结构体的指针。
SYSTEM_INFO, // 在Windows内部定义的一些结构体。
MEMORY_BASIC_INFORMATION as MEMINFO,
};
fn main() { // 这些变量的初始化代码会放在unsafe块中。为了使其在外部作用域中能够被访问到，所以需要在这里定义。
let this_pid: DWORD;
let this_proc: HANDLE;
let min_addr: LPVOID;
let max_addr: LPVOID;
let mut base_addr: PVOID;
let mut proc_info: SYSTEM_INFO;
let mut mem_info: MEMORY_BASIC_INFORMATION;
const MEMINFO_SIZE: usize = std::mem::size_of::<MEMINFO>();
unsafe { // 这个代码块保证了所有内存被初始化。
base_addr = std::mem::zeroed();
proc_info = std::mem::zeroed();
mem_info = std::mem::zeroed();
}
unsafe { // 在这个代码块中，是发起系统调用的代码。
this_pid = kernel32::GetCurrentProcessId();
this_proc = kernel32::GetCurrentProcess();
kernel32::GetSystemInfo( // 此函数没有使用返回值，而是使用了C的惯用法，来把运行结果提供给调用方。我们提供一个指向某个预定义结构体的指针，然后在函数返回后读取该结构体的新值，以查看其结果。
&mut proc_info as LPSYSTEM_INFO
);
};
min_addr = proc_info.lpMinimumApplicationAddress; // 为了方便，此处重命名了这些变量。
max_addr = proc_info.lpMaximumApplicationAddress;
println!("{:?} @ {:p}", this_pid, this_proc);
println!("{:?}", proc_info);
println!("min: {:p}, max: {:p}", min_addr, max_addr);
loop { // 这个循环完成了扫描地址空间的工作。
let rc: SIZE_T = unsafe {
kernel32::VirtualQueryEx( // 这个系统调用，提供了这个正在运行的程序的内存地址空间中一个指定段的信息，此指定段的起始位置的地址是base_addr。
this_proc, base_addr,
&mut mem_info, MEMINFO_SIZE as SIZE_T)
};
if rc == 0 {
break
}
println!("{:#?}", mem_info);
base_addr = ((base_addr as u64) + mem_info.RegionSize) as PVOID;
}
}
// code result:
MEMORY_BASIC_INFORMATION { ⇽---- 这个结构体是在Windows API中定义的。
BaseAddress: 0x00007ffbe8d9b000,
AllocationBase: 0x0000000000000000,
AllocationProtect: 0, ⇽---- 这些字段是Windows API中定义的枚举体，它们是用整数来表示的。可以把它们解码为枚举体的变体名，但是如果不向此清单中添加额外的代码，就无法使用这些变体名。
RegionSize: 17568124928,
State: 65536,
Protect: 1,
Type: 0
}
MEMORY_BASIC_INFORMATION {
BaseAddress: 0x00007ffffffe0000,
AllocationBase: 0x00007ffffffe0000,
AllocationProtect: 2,
RegionSize: 65536,
State: 8192,
Protect: 1,
Type: 131072
6.4.5 第三步：读取和写入进程内存中的字节数据
操作系统提供了用于读取和写入内存的工具，甚至在其他程序中也可以完成。这是多种工具程序都会用到的一种基础技术，其中包括即时编译器(JIT)、程序调试器，还有帮助人们在游戏中"作弊”的程序。在Windows中，这个过程一般来说看起来像下面这个 Rust 风格的伪代码:
let pid = some_process_id;
OpenProcess(pid);
loop address space {
*call* VirtualQueryEx() to access the next memory segment
*scan* the segment by calling ReadProcessMemory(),
looking for a selected pattern
*call* WriteProcessMemory() with the desired value
}
Linux使用 process_vm_readv() 和 process_vm_writev() 提供了一个更简单的API。它们的功能类似于 Windows中的 ReadProcessMemory() 和 writeProcessMemory()。
1429
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
