Java知识分享网 - 轻松学习从此开始!    

Java知识分享网

Java1234官方群25:java1234官方群17
Java1234官方群25:838462530
        
SpringBoot+SpringSecurity+Vue+ElementPlus权限系统实战课程 震撼发布        

最新Java全栈就业实战课程(免费)

springcloud分布式电商秒杀实战课程

IDEA永久激活

66套java实战课程无套路领取

Java1234 VIP课程

软件定制开发论文过查重

Java1234至尊VIP(特价活动)
当前位置: 主页 > Java文档 > Java基础相关 >

Rust程序设计 PDF 下载


分享到:
时间:2023-01-21 08:59来源:http://www.java1234.com 作者:转载  侵权举报
本书由两位经验丰富的系统程序员撰写,介绍了一种具有C和C 性能,同时安全且支持并发的新型系统编程语言Rust,解释了Rust如何在性能和安全性之间架起桥梁,以及我们如何用好这门语
失效链接处理
Rust程序设计  PDF 下载


下载地址:
版权归出版社和原作者所有,链接已删除,请购买正版

用户下载说明:

电子版仅供预览,下载后24小时内务必删除,支持正版,喜欢的请购买正版书籍:
http://product.dangdang.com/29127955.html
 

相关截图:



资料简介:
本书由两位经验丰富的系统程序员撰写,介绍了一种具有C和C 性能,同时安全且支持并发的新型系统编程语言Rust,解释了Rust如何在性能和安全性之间架起桥梁,以及我们如何用好这门语言。书中主要内容包括:Rust的基本数据类型,关于所有权、引用等概念,表达式、错误处理、包和模块、结构体、枚举与模式等基础知识,Rust语言的特型与泛型,闭包,迭代器,集合,等等。

资料目录:
前言 xv
 
第 1 章 为什么是Rust 1
 
第 2 章 Rust初体验 5
 
2.1 下载和安装Rust 5
 
2.2 一个简单的函数 7
 
2.3 编写和运行单元测试 9
 
2.4 处理命令行参数 9
 
2.5 一个简单的Web服务器 13
 
2.6 并发 19
 
2.6.1 到底什么是曼德布洛特集合 19
 
2.6.2 解析成对的命令行参数 23
 
2.6.3 像素到复数的映射 25
 
2.6.4 绘制集合 26
 
2.6.5 写出图像文件 27
 
2.6.6 并发的曼德布洛特程序 29
 
2.6.7 运行曼德布洛特绘图器 32
 
2.6.8 安全无形 34
 
第 3 章 基本类型 35
 
3.1 机器类型 38
 
3.1.1 整数类型 38
 
3.1.2 浮点类型 40
 
3.1.3 布尔类型 42
 
3.1.4 字符类型 43
 
3.2 元组 44
 
3.3 指针类型 45
 
3.3.1 引用 46
 
3.3.2 Box 46
 
3.3.3 原始指针 46
 
3.4 数组、向量和切片 47
 
3.4.1 数组 47
 
3.4.2 向量 48
 
3.4.3 逐个元素地构建向量 51
 
3.4.4 切片 51
 
3.5 字符串类型 52
 
3.5.1 字符串字面量 52
 
3.5.2 字节字符串 53
 
3.5.3 字符串在内存中的表示 53
 
3.5.4 字符串 55
 
3.5.5 使用字符串 56
 
3.5.6 其他类似字符串的类型 56
 
3.6 更多类型 57
 
第 4 章 所有权 58
 
4.1 所有权 59
 
4.2 转移 63
 
4.2.1 更多转移操作 68
 
4.2.2 转移与控制流 69
 
4.2.3 转移与索引内容 69
 
4.3 Copy类型:转移的例外 71
 
4.4 Rc和Arc:共享所有权 74
 
第 5 章 引用 76
 
5.1 引用作为值 79
 
5.1.1 Rust引用与C 引用 79
 
5.1.2 给引用赋值 80
 
5.1.3 引用的引用 81
 
5.1.4 比较引用 81
 
5.1.5 引用永远不为空 82
 
5.1.6 借用对任意表达式的引用 82
 
5.1.7 对切片和特型对象的引用 83
 
5.2 引用安全 83
 
5.2.1 借用局部变量 83
 
5.2.2 接收引用作为参数 86
 
5.2.3 将引用作为参数传递 87
 
5.2.4 返回引用 88
 
5.2.5 结构体包含引用 89
 
5.2.6 不同的生命期参数 91
 
5.2.7 省略生命期参数 92
 
5.3 共享与修改 93
 
5.4 征服对象之海 99
 
第 6 章 表达式 101
 
6.1 表达式语言 101
 
6.2 块与分号 102
 
6.3 声明 103
 
6.4 if与match 105
 
6.5 循环 107
 
6.6 return表达式 109
 
6.7 为什么Rust有循环 110
 
6.8 函数与方法调用 111
 
6.9 字段与元素 112
 
6.10 引用操作符 113
 
6.11 算术、位、比较和逻辑操作符 113
 
6.12 赋值 114
 
6.13 类型转换 114
 
6.14 闭包 115
 
6.15 优先级与关联性 116
 
6.16 展望 118
 
第 7 章 错误处理 119
 
7.1 诧异 119
 
7.1.1 展开栈 120
 
7.1.2 中止进程 121
 
7.2 结果 121
 
7.2.1 捕获错误 121
 
7.2.2 结果类型别名 123
 
7.2.3 打印错误 123
 
7.2.4 传播错误 124
 
7.2.5 处理多种错误类型 125
 
7.2.6 处理“不会发生”的错误 127
 
7.2.7 忽略错误 128
 
7.2.8 在main()中处理错误 128
 
7.2.9 声明自定义错误类型 129
 
7.2.10 为什么是结果 130
 
第 8 章 包和模块 131
 
8.1 包 131
 
8.2 模块 134
 
8.2.1 把模块写在单独的文件中 135
 
8.2.2 路径和导入 136
 
8.2.3 标准前置模块 138
 
8.2.4 特性项,Rust的基础 139
 
8.3 将程序作为库发布 141
 
8.4 src/bin目录 142
 
8.5 属性 143
 
8.6 测试和文档 145
 
8.6.1 集成测试 147
 
8.6.2 文档 148
 
8.6.3 文档测试 149
 
8.7 指定依赖 152
 
8.7.1 版本 152
 
8.7.2 Cargo.lock 153
 
8.8 把包发布到crates.io 154
 
8.9 工作空间 156
 
8.10 还有惊喜 156
 
第 9 章 结构体 158
 
9.1 命名字段结构体 158
 
9.2 类元组结构体 161
 
9.3 类基元结构体 161
 
9.4 结构体布局 162
 
9.5 通过impl定义方法 162
 
9.6 泛型结构体 165
 
9.7 带生命期参数的结构体 167
 
9.8 为结构体类型派生共有特型 168
 
9.9 内部修改能力 168
 
第 10 章 枚举与模式 172
 
10.1 枚举 173
 
10.1.1 包含数据的枚举 175
 
10.1.2 枚举的内存布局 176
 
10.1.3 使用枚举的富数据结构 176
 
10.1.4 泛型枚举 178
 
10.2 模式 180
 
10.2.1 模式中的字面量、变量和通配符 183
 
10.2.2 元组与结构体模式 184
 
10.2.3 引用模式 185
 
10.2.4 匹配多种可能性 187
 
10.2.5 模式护具 188
 
[email protected]
 
10.2.7 在哪里使用模式 189
 
10.2.8 填充二叉树 190
 
10.3 设计的考量 191
 
第 11 章 特型与泛型 192
 
11.1 使用特型 193
 
11.1.1 特型目标 194
 
11.1.2 特型目标布局 195
 
11.1.3 泛型函数 196
 
11.1.4 使用哪一个 199
 
11.2 定义和实现特型 200
 
11.2.1 默认方法 201
 
11.2.2 特型与其他人的类型 202
 
11.2.3 特型中的Self 204
 
11.2.4 子特型 205
 
11.2.5 静态方法 205
 
11.3 完全限定方法调用 207
 
11.4 定义类型关系的特型 208
 
11.4.1 关联类型(或迭代器工作原理) 208
 
11.4.2 泛型特型(或操作符重载的原理) 211
 
11.4.3 伴型特型(或rand::random()工作原理) 212
 
11.5 逆向工程绑定 213
 
11.6 小结 216
 
第 12 章 操作符重载 217
 
12.1 算术与位操作符 218
 
12.1.1 一元操作符 220
 
12.1.2 二元操作符 221
 
12.1.3 复合赋值操作符 221
 
12.2 相等测试 222
 
12.3 顺序比较 225
 
12.4 Index与IndexMut 227
 
12.5 其他操作符 229
 
第 13 章 实用特型 230
 
13.1 Drop 231
 
13.2 Sized 233
 
13.3 Clone 235
 
13.4 Copy 236
 
13.5 Deref与DerefMut 237
 
13.6 Default 239
 
13.7 AsRef与AsMut 241
 
13.8 Borrow与BorrowMut 242
 
13.9 From与Into 244
 
13.10 ToOwned 245
 
13.11 Borrow与ToOwned实例:谦逊的奶牛(Cow) 246
 
第 14 章 闭包 248
 
14.1 捕获变量 249
 
14.1.1 借用值的闭包 250
 
14.1.2 盗用值的闭包 250
 
14.2 函数与闭包类型 252
 
14.3 闭包的性能 254
 
14.4 闭包和安全 255
 
14.4.1 杀值的闭包 255
 
14.4.2 FnOnce 256
 
14.4.3 FnMut 257
 
14.5 回调 259
 
14.6 有效使用闭包 261
 
第 15 章 迭代器 263
 
15.1 Iterator和IntoIterator特型 264
 
15.2 创建迭代器 265
 
15.2.1 iter和iter_mut方法 265
 
15.2.2 IntoIterator实现 266
 
15.2.3 drain方法 268
 
15.2.4 其他迭代器源 268
 
15.3 迭代器适配器 269
 
15.3.1 map和filter 269
 
15.3.2 filter_map和flat_map 271
 
15.3.3 scan 273
 
15.3.4 take和take_while 274
 
15.3.5 skip和skip_while 274
 
15.3.6 peekable 275
 
15.3.7 fuse 276
 
15.3.8 可逆迭代器与rev 277
 
15.3.9 inspect 278
 
15.3.10 chain 278
 
15.3.11 enumerate 279
 
15.3.12 zip 279
 
15.3.13 by_ref 280
 
15.3.14 cloned 281
 
15.3.15 cycle 281
 
15.4 消费迭代器 282
 
15.4.1 简单累计:count、sum和product 282
 
15.4.2 max和min 283
 
15.4.3 max_by和min_by 283
 
15.4.4 max_by_key和min_by_key 283
 
15.4.5 比较项序列 284
 
15.4.6 any和all 285
 
15.4.7 position、rposition和ExactSizeIterator 285
 
15.4.8 fold 285
 
15.4.9 nth 286
 
15.4.10 last 286
 
15.4.11 find 287
 
15.4.12 构建集合:collect和FromIterator 287
 
15.4.13 Extend特型 289
 
15.4.14 partition 289
 
15.5 实现自己的迭代器 290
 
第 16 章 集合 294
 
16.1 概述 295
 
16.2 Vec 296
 
16.2.1 访问元素 296
 
16.2.2 迭代 298
 
16.2.3 增长和收缩向量 298
 
16.2.4 连接 300
 
16.2.5 拆分 301
 
16.2.6 交换 303
 
16.2.7 排序和搜索 303
 
16.2.8 比较切片 304
 
16.2.9 随机元素 305
 
16.2.10 Rust排除无效错误 305
 
16.3 VecDeque 306
 
16.4 LinkedList 307
 
16.5 BinaryHeap 308
 
16.6 HashMap和BTreeMap 309
 
16.6.1 条目 311
 
16.6.2 映射迭代 313
 
16.7 HashSet和BTreeSet 313
 
16.7.1 集迭代 314
 
16.7.2 相等的值不相同 314
 
16.7.3 整集操作 315
 
16.8 散列 316
 
16.9 标准集合之外 318
 
第 17 章 字符串与文本 319
 
17.1 Unicode背景知识 319
 
17.1.1 ASCII、Latin-1和Unicode 320
 
17.1.2 UTF-8 320
 
17.1.3 文本方向性 322
 
17.2 字符(char) 322
 
17.2.1 字符分类 322
 
17.2.2 处理数字 322
 
17.2.3 字符大小写转换 323
 
17.2.4 与整数相互转换 324
 
17.3 String与str 324
 
17.3.1 创建字符串值 325
 
17.3.2 简单检查 325
 
17.3.3 追加和插入文本 326
 
17.3.4 删除文本 327
 
17.3.5 搜索与迭代的约定 327
 
17.3.6 搜索文本的模式 328
 
17.3.7 搜索与替换 328
 
17.3.8 迭代文本 329
 
17.3.9 修剪 331
 
17.3.10 字符串大小写转换 331
 
17.3.11 从字符串解析出其他类型 331
 
17.3.12 将其他类型转换为字符串 332
 
17.3.13 作为其他类文本类型借用 333
 
17.3.14 访问UTF-8格式的文本 333
 
17.3.15 从UTF-8数据产生文本 334
 
17.3.16 阻止分配 335
 
17.3.17 字符串作为泛型集合 336
 
17.4 格式化值 337
 
17.4.1 格式化文本值 338
 
17.4.2 格式化数值 339
 
17.4.3 格式化其他类型 341
 
17.4.4 为调试格式化值 341
 
17.4.5 为调试格式化指针 342
 
17.4.6 通过索引或名字引用参数 342
 
17.4.7 动态宽度与精度 343
 
17.4.8 格式化自定义类型 344
 
17.4.9 在你的代码中使用格式化语言 345
 
17.5 正则表达式 346
 
17.5.1 基本用法 347
 
17.5.2 懒构建Regex值 348
 
17.6 规范化 349
 
17.6.1 规范化形式 350
 
17.6.2 unicode-normalization包 351
 
第 18 章 输入和输出 352
 
18.1 读取器和写入器 353
 
18.1.1 读取器 354
 
18.1.2 缓冲读取器 355
 
18.1.3 读取文本行 356
 
18.1.4 收集行 358
 
18.1.5 写入器 359
 
18.1.6 文件 360
 
18.1.7 搜寻 360
 
18.1.8 其他读取器和写入器类型 361
 
18.1.9 二进制数据、压缩与序列化 362
 
18.2 文件与目录 364
 
18.2.1 OsStr和Path 364
 
18.2.2 Path和PathBuf的方法 365
 
18.2.3 文件系统访问函数 367
 
18.2.4 读取目录 368
 
18.2.5 平台特定的特性 369
 
18.3 网络编程 370
 
第 19 章 并发 373
 
19.1 并行分叉?C合并 374
 
19.1.1 产生及合并 376
 
19.1.2 跨线程错误处理 377
 
19.1.3 跨线程共享不可修改数据 378
 
19.1.4 Rayon 380
 
19.1.5 重温曼德布洛特集合 382
 
19.2 通道 383
 
19.2.1 发送值 385
 
19.2.2 接收值 387
 
19.2.3 运行管道 388
 
19.2.4 通道特性与性能 390
 
19.2.5 线程安全:Send与Sync 391
 
19.2.6 将所有迭代器都接到通道上 393
 
19.2.7 超越管道 394
 
19.3 共享可修改状态 395
 
19.3.1 什么是互斥量 395
 
19.3.2 Mutex 397
 
19.3.3 mut与Mutex 398
 
19.3.4 互斥量的问题 399
 
19.3.5 死锁 399
 
19.3.6 中毒的互斥量 400
 
19.3.7 使用互斥量的多消费者通道 400
 
19.3.8 读/写锁(RwLock) 401
 
19.3.9 条件变量(Condvar)402
 
19.3.10 原子类型 403
 
19.3.11 全局变量 404
 
19.4 习惯编写Rust并发代码 406
 
第 20 章 宏 407
 
20.1 宏基础 408
 
20.1.1 宏扩展基础 409
 
20.1.2 意外结果 410
 
20.1.3 重复 411
 
20.2 内置宏 413
 
20.3 调试宏 414
 
20.4 json!宏 415
 
20.4.1 片段类型 416
 
20.4.2 在宏里使用递归 419
 
20.4.3 在宏里使用特型 419
 
20.4.4 作用域与自净宏 421
 
20.4.5 导入和导出宏 424
 
20.5 匹配时避免语法错误 425
 
20.6 超越macro_rules! 426
 
第 21 章 不安全代码 427
 
21.1 不安全源自哪里 428
 
21.2 不安全的块 429
 
21.3 不安全的函数 431
 
21.4 不安全的块还是不安全的函数 433
 
21.5 未定义行为 434
 
21.6 不安全的特型 435
 
21.7 原始指针 437
 
21.7.1 安全解引用原始指针 439
 
21.7.2 示例:RefWithFlag 440
 
21.7.3 可空指针 442
 
21.7.4 类型大小与对齐 442
 
21.7.5 指针算术 443
 
21.7.6 移入和移出内存 444
 
21.7.7 示例:GapBuffer 447
 
21.7.8 不安全代码中的诧异安全性 453
 
21.8 外来函数:在Rust中调用C和C  453
 
21.8.1 查找共有数据表示 454
 
21.8.2 声明外来函数和变量 456
 
21.8.3 使用库函数 458
 
21.8.4 libgit2的原始接口 461
 
21.8.5 libgit2的安全接口 466
 
21.9 小结 475
 
作者介绍 476
 
封面介绍 476
------分隔线----------------------------

锋哥公众号


锋哥微信


关注公众号
【Java资料站】
回复 666
获取 
66套java
从菜鸡到大神
项目实战课程

锋哥推荐