RUST程序设计(第2版)

目录

专家推荐

译者序

前言

中文版审读致谢

第 1章　系统程序员也能享受美好 1

1.1　Rust为你负重前行 2

1.2　高效并行编程 3

1.3　性能毫不妥协 3

1.4　协作无边无界 4

第 2章　Rust导览 5

2.1　rustup与Cargo 6

2.2　Rust函数 8

2.3　编写与运行单元测试 9

2.4　处理命令行参数 10

2.5　搭建Web服务器 13

2.6　并发 18

2.6.1　什么是曼德博集 19

2.6.2　解析并配对命令行参数 22

2.6.3　从像素到复数的映射 24

2.6.4　绘制曼德博集 25

2.6.5　写入图像文件 26

2.6.6　并发版曼德博程序 27

2.6.7　运行曼德博绘图器 32

2.6.8　大“安”无形 33

2.7　文件系统与命令行工具 33

2.7.1　命令行界面 34

2.7.2　读写文件 36

2.7.3　查找并替换 37

第3章　基本数据类型 39

3.1　固定宽度的数值类型 41

3.1.1　整型 42

3.1.2　检查算法、回绕算法、饱和算法和溢出算法 45

3.1.3　浮点类型 46

3.2　布尔类型 48

3.3　字符 49

3.4　元组 50

3.5　指针类型 51

3.5.1　引用 52

3.5.2　Box 52

3.5.3　裸指针 53

3.6　数组、向量和切片 53

3.6.1　数组 53

3.6.2　向量 54

3.6.3　切片 57

3.7　字符串类型 58

3.7.1　字符串字面量 58

3.7.2　字节串 59

3.7.3　内存中的字符串 60

3.7.4　String 61

3.7.5　使用字符串 62

3.7.6　其他类似字符串的类型 62

3.8　类型别名 63

3.9　前路展望 63

第4章　所有权与移动 64

4.1　所有权 65

4.2　移动 70

4.2.1　更多移动类操作 74

4.2.2　移动与控制流 75

4.2.3　移动与索引内容 75

4.3　Copy类型：关于移动的例外情况 77

4.4　Rc与Arc：共享所有权 80

第5章　引用 83

5.1　对值的引用 84

5.2　使用引用 86

5.2.1　Rust引用与C 引用 87

5.2.2　对引用变量赋值 88

5.2.3　对引用进行引用 88

5.2.4　比较引用 89

5.2.5　引用永不为空 89

5.2.6　借用任意表达式结果值的引用 89

5.2.7　对切片和特型对象的引用 90

5.3　引用安全 90

5.3.1　借用局部变量 91

5.3.2　将引用作为函数参数 93

5.3.3　把引用传给函数 95

5.3.4　返回引用 95

5.3.5　包含引用的结构体 96

5.3.6　不同的生命周期参数 98

5.3.7　省略生命周期参数 100

5.4　共享与可变 101

5.5　应对复杂对象关系 107

第6章　表达式 109

6.1　表达式语言 109

6.2　优先级与结合性 110

6.3　块与分号 112

6.4　声明 113

6.5　if与match 115

6.5.1　if let 117

6.5.2　循环 117

6.6　循环中的控制流 119

6.7　return表达式 120

6.8　为什么Rust中会有loop 121

6.9　函数与方法调用 122

6.10　字段与元素 123

6.11　引用运算符 124

6.12　算术运算符、按位运算符、比较运算符和逻辑运算符 125

6.13　赋值 125

6.14　类型转换 126

6.15　闭包 127

6.16　前路展望 127

第7章　错误处理 128

7.1　panic 128

7.1.1　展开调用栈 129

7.1.2　中止 130

7.2　Result 130

7.2.1　捕获错误 131

7.2.2　Result类型别名 132

7.2.3　打印错误 132

7.2.4　传播错误 134

7.2.5　处理多种Error类型 135

7.2.6　处理“不可能发生”的错误 136

7.2.7　忽略错误 138

7.2.8　处理main()中的错误 138

7.2.9　声明自定义错误类型 139

7.2.10　为什么是Result 140

第8章　crate与模块 141

8.1　crate 141

8.1.1　版本 144

8.1.2　创建配置文件 145

8.2　模块 145

8.2.1　嵌套模块 146

8.2.2　单独文件中的模块 147

8.2.3　路径与导入 149

8.2.4　标准库预导入 152

8.2.5　公开use声明 152

8.2.6　公开结构体字段 152

8.2.7　静态变量与常量 153

8.3　将程序变成库 153

8.4　src/bin目录 155

8.5　属性 156

8.6　测试与文档 158

8.6.1　集成测试 161

8.6.2　文档 161

8.6.3　文档测试 163

8.7　指定依赖项 166

8.7.1　版本 166

8.7.2　Cargo.lock 167

8.8　将crate发布到crates.io 168

8.9　工作空间 170

8.10　更多好资源 170

第9章　结构体 172

9.1　具名字段型结构体 172

9.2　元组型结构体 175

9.3　单元型结构体 175

9.4　结构体布局 176

9.5　用impl定义方法 177

9.5.1　以Box、Rc或Arc形式传入self 179

9.5.2　类型关联函数 179

9.6　关联常量 180

9.7　泛型结构体 181

9.8　带生命周期参数的泛型结构体 183

9.9　带常量参数的泛型结构体 183

9.10　让结构体类型派生自某些公共特型 185

9.11　内部可变性 186

第 10章　枚举与模式 190

10.1　枚举 191

10.1.1　带数据的枚举 193

10.1.2　内存中的枚举 194

10.1.3　用枚举表示富数据结构 194

10.1.4　泛型枚举 196

10.2　模式 198

10.2.1　模式中的字面量、变量和通配符 201

10.2.2　元组型模式与结构体型模式 202

10.2.3　数组型模式与切片型模式 203

10.2.4　引用型模式 204

10.2.5　匹配守卫 206

10.2.6　匹配多种可能性 206

10.2.7　使用@模式绑定 207

10.2.8　模式能用在哪里 207

10.2.9　填充二叉树 209

10.3　大局观 210

第 11章　特型与泛型 211

11.1　使用特型 213

11.1.1　特型对象 214

11.1.2　泛型函数与类型参数 215

11.1.3　使用哪一个 219

11.2　定义与实现特型 220

11.2.1　默认方法 221

11.2.2　特型与其他人的类型 222

11.2.3　特型中的Self 224

11.2.4　子特型 225

11.2.5　类型关联函数 226

11.3　完全限定的方法调用 227

11.4　定义类型之间关系的特型 228

11.4.1　关联类型（或迭代器的工作原理） 229

11.4.2　泛型特型（或运算符重载的工作原理） 231

11.4.3　impl Trait 232

11.4.4　关联常量 234

11.5　逆向工程求限界 235

11.6　以特型为基础 238

第 12章　运算符重载 239

12.1　算术运算符与按位运算符 240

12.1.1　一元运算符 242

12.1.2　二元运算符 243

12.1.3　复合赋值运算符 244

12.2　相等性比较 245

12.3　有序比较 247

12.4　Index与IndexMut 250

12.5　其他运算符 252

第 13章　实用工具特型 253

13.1　Drop 254

13.2　Sized 256

13.3　Clone 259

13.4　Copy 260

13.5　Deref与DerefMut 260

13.6　Default 263

13.7　AsRef与AsMut 264

13.8　Borrow与BorrowMut 266

13.9　From与Into 267

13.10　TryFrom与TryInto 270

13.11　ToOwned 271

13.12　Borrow与ToOwned的实际运用：谦卑的Cow 271

第 14章　闭包 273

14.1　捕获变量 274

14.1.1　借用值的闭包 275

14.1.2　“窃取”值的闭包 275

14.2　函数与闭包的类型 277

14.3　闭包性能 279

14.4　闭包与安全 280

14.4.1　“杀死”闭包 280

14.4.2　FnOnce 281

14.4.3　FnMut 282

14.4.4　对闭包的Copy与Clone 284

14.5　回调 285

14.6　高效地使用闭包 288

第 15章　迭代器 290

15.1　Iterator特型与IntoIterator特型 291

15.2　创建迭代器 292

15.2.1　iter方法与iter_mut方法 293

15.2.2　IntoIterator的实现 293

15.2.3　from_fn与successors 295

15.2.4　drain方法 296

15.2.5　其他迭代器源 297

15.3　迭代器适配器 298

15.3.1　map与filter 298

15.3.2　filter_map与flat_map 300

15.3.3　flatten 302

15.3.4　take与take_while 304

15.3.5　skip与skip_while 305

15.3.6　peekable 305

15.3.7　fuse 306

15.3.8　可逆迭代器与rev 307

15.3.9　inspect 308

15.3.10　chain 309

15.3.11　enumerate 309

15.3.12　zip 310

15.3.13　by_ref 310

15.3.14　cloned与copied 311

15.3.15　cycle 312

15.4　消耗迭代器 313

15.4.1　简单累加：count、sum和product 313

15.4.2　min与max 313

15.4.3　max_by与min_by 314

15.4.4　max_by_key与min_by_key 314

15.4.5　对条目序列进行比较 315

15.4.6　any与all 315

15.4.7　position、rposition和ExactSizeIterator 316

15.4.8　fold与rfold 316

15.4.9　try_fold与try_rfold 317

15.4.10　nth与nth_back 318

15.4.11　last 319

15.4.12　find、rfind和find_map 319

15.4.13　构建集合：collect与FromIterator 320

15.4.14　Extend特型 322

15.4.15　partition 322

15.4.16　for_each与try_for_each 323

15.5　实现自己的迭代器 324

第 16章　集合 328

16.1　概述 329

16.2　Vec 330

16.2.1　访问元素 331

16.2.2　迭代 332

16.2.3　扩大向量与收缩向量 332

16.2.4　联结 336

16.2.5　拆分 336

16.2.6　交换 339

16.2.7　填充 339

16.2.8　排序与搜索 339

16.2.9　比较切片 341

16.2.10　随机元素 341

16.2.11　Rust中不存在失效型错误 342

16.3　VecDeque 343

16.4　BinaryHeap 344

16.5　HashMap与BTreeMap 346

16.5.1　条目 349

16.5.2　对Map进行迭代 351

16.6　HashSet与BTreeSet 351

16.6.1　对Set进行迭代 352

16.6.2　当相等的值不完全相同时 353

16.6.3　针对整个Set的运算 353

16.7　哈希 354

16.8　使用自定义哈希算法 355

16.9　在标准集合之外 357

第 17章　字符串与文本 358

17.1　一些Unicode背景知识 358

17.1.1　ASCII、Latin-1和Unicode 359

17.1.2　UTF-8编码 359

17.1.3　文本方向性 361

17.2　字符（char） 361

17.2.1　字符分类 361

17.2.2　处理数字 362

17.2.3　字符大小写转换 363

17.2.4　与整数之间的转换 364

17.3　String与str 364

17.3.1　创建字符串值 365

17.3.2　简单探查 366

17.3.3　追加文本与插入文本 366

17.3.4　移除文本与替换文本 368

17.3.5　搜索与迭代的约定 368

17.3.6　搜索文本的模式 369

17.3.7　搜索与替换 370

17.3.8　遍历文本 371

17.3.9　修剪 373

17.3.10　字符串的大小写转换 374

17.3.11　从字符串中解析出其他类型 374

17.3.12　将其他类型转换为字符串 374

17.3.13　借用其他类似文本的类型 375

17.3.14　以UTF-8格式访问文本 376

17.3.15　从UTF-8数据生成文本 376

17.3.16　推迟分配 377

17.3.17　把字符串当作泛型集合 379

17.4　格式化各种值 379

17.4.1　格式化文本值 380

17.4.2　格式化数值 381

17.4.3　格式化其他类型 383

17.4.4　格式化值以进行调试 383

17.4.5　格式化指针以进行调试 384

17.4.6　按索引或名称引用参数 385

17.4.7　动态宽度与动态精度 386

17.4.8　格式化自己的类型 386

17.4.9　在自己的代码中使用格式化语言 388

17.5　正则表达式 389

17.5.1　Regex的基本用法 389

17.5.2　惰性构建正则表达式值 390

17.6　规范化 391

17.6.1　规范化形式 392

17.6.2　unicode-normalization crate 393

第 18章　输入与输出 395

18.1　读取器与写入器 396

18.1.1　读取器 397

18.1.2　缓冲读取器 398

18.1.3　读取行 399

18.1.4　收集行 401

18.1.5　写入器 402

18.1.6　文件 403

18.1.7　寻址 404

18.1.8　其他读取器与写入器类型 404

18.1.9　二进制数据、压缩和序列化 406

18.2　文件与目录 407

18.2.1　OsStr与Path 408

18.2.2　Path与PathBuf的方法 409

18.2.3　访问文件系统的函数 411

18.2.4　读取目录 412

18.2.5　特定于平台的特性 413

18.3　网络 414

第 19章　并发 417

19.1　分叉与合并并行 418

19.1.1　启动与联结 420

19.1.2　跨线程错误处理 422

19.1.3　跨线程共享不可变数据 422

19.1.4　rayon 424

19.1.5　重温曼德博集 426

19.2　通道 427

19.2.1　发送值 429

19.2.2　接收值 431

19.2.3　运行管道 432

19.2.4　通道的特性与性能 434

19.2.5　线程安全：Send与Sync 435

19.2.6　绝大多数迭代器能通过管道传给通道 437

19.2.7　除管道之外的用法 438

19.3　共享可变状态 439

19.3.1　什么是互斥锁 439

19.3.2　Mutex 440

19.3.3　mut与互斥锁 442

19.3.4　为什么互斥锁不是“银弹” 443

19.3.5　死锁 443

19.3.6　“中毒”的互斥锁 444

19.3.7　使用互斥锁的多消费者通道 444

19.3.8　读/写锁（RwLock） 445

19.3.9　条件变量（Condvar） 446

19.3.10　原子化类型 447

19.3.11　全局变量 448

19.4　在Rust中编写并发代码的一点儿经验 451

第 20章　异步编程 452

20.1　从同步到异步 453

20.1.1　Future 455

20.1.2　异步函数与await表达式 456

20.1.3　从同步代码调用异步函数：block_on 458

20.1.4　启动异步任务 460

20.1.5　异步块 464

20.1.6　从异步块构建异步函数 466

20.1.7　在线程池中启动异步任务 467

20.1.8　你的Future实现Send了吗 467

20.1.9　长时间运行的计算：yield_now与spawn_blocking 470

20.1.10　对几种异步设计进行比较 471

20.1.11　一个真正的异步HTTP客户端 471

20.2　异步客户端与服务器 472

20.2.1　Error类型与Result类型 474

20.2.2　协议 474

20.2.3　获取用户输入：异步流 475

20.2.4　发送数据包 477

20.2.5　接收数据包：更多异步流 478

20.2.6　客户端的main函数 480

20.2.7　服务器的main函数 481

20.2.8　处理聊天连接：异步互斥锁 482

20.2.9　群组表：同步互斥锁 484

20.2.10　聊天组：tokio的广播通道 485

20.3　原始Future与执行器：Future什么时候值得再次轮询 488

20.3.1　调用唤醒器：spawn_blocking 489

20.3.2　实现block_on 491

20.4　固定（Pin） 493

20.4.1　Future生命周期的两个阶段 493

20.4.2　固定指针 496

20.4.3　Unpin特型 497

20.5　什么时候要用异步代码 498

第 21章　宏 500

21.1　宏基础 501

21.1.1　宏展开的基础 502

21.1.2　意外后果 503

21.1.3　重复 505

21.2　内置宏 507

21.3　调试宏 508

21.4　构建json!宏 509

21.4.1　片段类型 510

21.4.2　宏中的递归 513

21.4.3　将特型与宏一起使用 514

21.4.4　作用域界定与卫生宏 516

21.4.5　导入宏和导出宏 518

21.5　在匹配过程中避免语法错误 519

21.6　超越macro_rules! 520

第 22章　不安全代码 522

22.1　不安全因素来自哪里 523

22.2　不安全块 524

22.3　示例：高效的ASCII字符串类型 525

22.4　不安全函数 527

22.5　不安全块还是不安全函数 528

22.6　未定义行为 529

22.7　不安全特型 531

22.8　裸指针 532

22.8.1　安全地解引用裸指针 534

22.8.2　示例：RefWithFlag 535

22.8.3　可空指针 537

22.8.4　类型大小与对齐方式 537

22.8.5　指针运算 538

22.8.6　移动入和移动出内存 539

22.8.7　示例：GapBuffer 542

22.8.8　不安全代码中的panic安全性 548

22.9　用联合体重新解释内存 549

22.10　匹配联合体 551

22.11　借用联合体 551

第 23章　外部函数 552

23.1　寻找共同的数据表示 552

23.2　声明外部函数与变量 556

23.3　使用库中的函数 557

23.4　libgit2的裸接口 560

23.5　libgit2的安全接口 566

23.6　结论 575

作者介绍 576

封面介绍 576