Rust1.9
Rust1.9
中最大的变化是稳定了包括停止恐慌
启动的展开
过程方法的std::panic
模块:
cpp
use std::panic;
let result = panic::catch_unwind(|| {
println!("hello!");
});
assert!(result.is_ok());
let result = panic::catch_unwind(|| {
panic!("oh no!");
});
assert!(result.is_err());
1,已添加追加
方法到BinaryHeap,BTreeMap
和BTreeSet
中.此外,已添加split_off
到BTreeMap
,因此BTreeSet::split_off
.
2,在libstd
的f32
和f64
类型上,有to_degrees
和to_radians
方法,但现在它们也在libcore
中.
3,Iterator
有两个新方法:sum
和product
4,Cell
和RefCell
都有了get_mut
.
5,与assert!
一样,assert_eq!
接受自定义
错误消息.
?号
Rust
获得了个新的?
符号,假设有从文件
中读取一些数据:
cpp
fn read_username_from_file() -> Result<String, io::Error> {
let f = File::open("username.txt");
let mut f = match f {
Ok(file) => file,
Err(e) => return Err(e),
};
let mut s = String::new();
match f.read_to_string(&mut s) {
Ok(_) => Ok(s),
Err(e) => Err(e),
}
}
此代码
有两条
可能失败
路径,即打开文件
,及从中读取数据
.如果其中一个不管用,想从read_username_from_file
返回错误
.
这里,涉及匹配I/O
操作结果.但是,都是样板.
用?
,上面
代码如下:
cpp
fn read_username_from_file() -> Result<String, io::Error> {
let mut f = File::open("username.txt")?;
let mut s = String::new();
f.read_to_string(&mut s)?;
Ok(s)
}
这是简写.即?
针对Result
值,如果它是Ok
,则解包
它并给出内部值
.如果是Err
,则从你当前所在的函数返回.
在1.13
之前,read_username_from_file
可这样实现:
cpp
fn read_username_from_file() -> Result<String, io::Error> {
let mut f = try!(File::open("username.txt"));
let mut s = String::new();
try!(f.read_to_string(&mut s));
Ok(s)
}
多次调用try
时,非常没有吸引力
;要用更甜蜜
的语法.!是连续使用的.考虑:
cpp
try!(try!(try!(foo()).bar()).baz())
//对比
foo()?.bar()?.baz()?
1.15.1
稳定版
此版本修复了两个问题,即新vec::IntoIter::as_mut_slice
方法中的健全性错误,及Rust
发布版的某些C组件未使用-fPIC
编译的回归
问题.
as_mut_slice
是个三行函数,在发布Rust1.15.0
几分钟后就发现了该问题,提醒人们编写不安全
代码的危险.
as_mut_slice
是Vec
类型的IntoIter
迭代器上的一个方法,它提供了正在迭代缓冲
的可变视图
.从概念上讲,它很简单:只需返回缓冲
引用;
事实上,实现
很简单,但它是不安全
的,因为IntoIter
是用缓冲
的不安全指针
实现的:
cpp
pub fn as_mut_slice(&self) -> &mut [T] {
unsafe {
slice::from_raw_parts_mut(self.ptr as *mut T, self.len())
}
}
此方法带共享引用
,且不安全
地从可变引用
继承.即as_mut_slice
可生成同一缓冲
的多个可变
引用,这是在Rust
中是禁止
的.
下面说明
该错误:
cpp
fn main() {
let v = vec![0];
let v_iter = v.into_iter();
let slice1: &mut [_] = v_iter.as_mut_slice();
let slice2: &mut [_] = v_iter.as_mut_slice();
slice1[0] = 1;
slice2[0] = 2;
}
这里slice1
和slice2
都引用
了同一个可变
切片.注意,v_iter
迭代器未按可变
声明,很可疑.
修复很简单,只需将&self
更改为&mut self
:
cpp
pub fn as_mut_slice(&mut self) -> &mut [T] {
unsafe {
slice::from_raw_parts_mut(self.ptr as *mut T, self.len())
}
}
这样,可保持唯一可变
,且必须声明v_iter
为可变
切片才能取
可变切片.
1.17.0
稳定版
"静态生命期
"现在假定为静态和常量
.这样编写const
或static
时:
cpp
const NAME: &'static str = "Ferris";
static NAME: &'static str = "Ferris";
Rust1.17
允许省略"静
",因为这是唯一
有意义的生命期:
cpp
const NAME: &str = "Ferris";
static NAME: &str = "Ferris";
有时,可删除大量样板:
cpp
//老
const NAMES: &'static [&'static str; 2] = &["Ferris", "Bors"];
//新增功能
const NAMES: &[&str; 2] = &["Ferris", "Bors"];
另一个类似改进叫"对象字面
属性速记
",在声明
结构时可删除
重复项,如下:
cpp
//定义
struct Point {
x: i32,
y: i32,
}
let x = 5;
let y = 6;
//老
let p = Point {
x: x,
y: y,
};
//新增功能
let p = Point {
x,
y,
};
也即,x,y
形式假定
设置其值为域中同名变量
.
新手容易,把两个&strs
在一起.这不管用,只能String+&str
.因此.
cpp
//代码
"foo" + "bar"
//旧
error[E0369]: binary operation `+` cannot be applied to type `&'static str`
--> <anon>:2:5
|
2 | "foo" + "bar"
| ^^^^^
|
note: an implementation of `std::ops::Add` might be missing for `&'static str`
--> <anon>:2:5
|
2 | "foo" + "bar"
| ^^^^^
//新加功能
error[E0369]: binary operation `+` cannot be applied to type `&'static str`
--> <anon>:2:5
|
2 | "foo" + "bar"
| ^^^^^
|
= note: `+` can't be used to concatenate two `&str` strings
help
:to_owned()
可从串
创建"物主串
"
引用.把串
连接到右侧的串
可能需要重新分配.这需要串的所有权
cpp
| "foo".to_owned() + "bar"
使用Cargo
的构建脚本时,必须在Cargo.toml
中设置脚本
位置.然而,绝大多数人都写为build="build.rs"
,在项目的根目录中使用build.rs
文件.
此约定现在已编码到Cargo
中,如果存在build.rs
,则假定
此约定.可用build=false
选出.
扩展了一点pub
关键字.
cpp
pub(crate) bar;
()
里面是"限制位
",补充
如何公开
.上例一样使用crate
关键字,表明bar
对整个crate
但不是在它之外,是公开
的.
这样可更轻松
地声明"对crate
公开"但不向用户
公开的API
.
还可指定
路径,如下:
cpp
pub(in a::b::c) foo;
即仅在a::b::c
的层次中可用,其他地方不可用.
对窗口
用户,Rust1.18.0
有个新属性,#![windows_subsystem]
.工作原理如下:
cpp
#![windows_subsystem = "console"]
#![windows_subsystem = "windows"]
控制
链接器中的/SUBSYSTEM
标志.目前,仅支持"控制台"和"窗口"
.
最后,Rust
(没有#[repr]
)的元组,枚举变体字段和结构
总是有个未限定的布局
.开启了自动重排
功能,可减少填充
来减小尺寸.考虑此结构:
cpp
struct Suboptimal(u8, u16, u8);
在x86_64
平台上的Rust
早期版本中,此结构的大小为6个
字节.但查看源码,会期望有四个字节
.额外的两个
字节用来填充;
但是,如果像这样呢
cpp
struct Optimal(u8, u8, u16);
Rust1.19.0
第一个支持联
的版本:
cpp
union MyUnion {
f1: u32,
f2: f32,
}
联
类似枚举
,但它们没有"标签"
的.枚举
有运行时决定存储哪个变体的"标签"
;联
省略了该标签
.
因为可用错误
变体解释
联中保存数据,而Rust
无法检查这一点,即读写
联字段是不安全
的:
cpp
let u = MyUnion { f1: 1 };
unsafe { u.f1 = 5 };
let value = unsafe { u.f1 };
模式匹配
也有效:
cpp
fn f(u: MyUnion) {
unsafe {
match u {
MyUnion { f1: 10 } => { println!("ten"); }
MyUnion { f2 } => { println!("{}", f2); }
}
}
}
主要用来与C互操作.
循环
现在可中断
一个值:
cpp
//旧代码
let x;
loop {
x = 7;
break;
}
//新代码
let x = loop { break 7; };
不抓
环境的闭包
现在可转换为函数指针
:
cpp
let f: fn(i32) -> i32 = |x| x + 1;
1.20.0
稳定版
以前Rust
版本中,已可定义有"关联函数"
的特征,结构和枚举
:
cpp
struct Struct;
impl Struct {
fn foo() {
println!("foo是构的关联函数");
}
}
fn main() {
Struct::foo();
}
还增加了定义"关联常量"
的功能:
cpp
struct Struct;
impl Struct {
const ID: u32 = 0;
}
fn main() {
println!("id为: {}", Struct::ID);
}
也即,常量ID
与Struct
相关联.与函数一样,关联常量
也适合特征和枚举
.
对特征
,可像使用关联类型
一样使用关联常量
:声明它,但不给它一个值.
然后,特征
实现者在实现
时声明
其值:
cpp
trait Trait {
const ID: u32;
}
struct Struct;
impl Trait for Struct {
const ID: u32 = 5;
}
fn main() {
println!("{}", Struct::ID);
}
此版本之前,必须如下写:
cpp
trait Float {
fn nan() -> Self;
fn infinity() -> Self;
...
}
这有点笨拙,且因为是函数
,即使只返回一个常量
,也不能在常量式
中使用它们
.因此,Float
的设计还必须包含
常量:
cpp
mod f32 {
const NAN: f32 = 0.0f32 / 0.0f32;
const INFINITY: f32 = 1.0f32 / 0.0f32;
impl Float for f32 {
fn nan() -> Self {
f32::NAN
}
fn infinity() -> Self {
f32::INFINITY
}
}
}
通过关联
常量,可更简洁
地如下定义特征
:
cpp
trait Float {
const NAN: Self;
const INFINITY: Self;
...
}
实现:
cpp
mod f32 {
impl Float for f32 {
const NAN: f32 = 0.0f32 / 0.0f32;
const INFINITY: f32 = 1.0f32 / 0.0f32;
}
}
更干净,更通用.
还修复了include!
文档测试中的宏
:
首先,改了一些字面
.考虑如下代码:
cpp
let x = &5;
在Rust
中,这段代码
等价:
cpp
let _x = 5;
let x = &_x;
也即,这里在栈
中存储,或可能在寄存器
中存储5
.x
是引用它.
但是,因为它是个整数字面
,因此不必是局部
的.考虑,有个带静态参数
的函数,如std::thread::spawn
.可这样使用x
:
cpp
use std::thread;
fn main() {
let x = &5;
thread::spawn(move || {
println!("{}", x);
});
}
在以前的Rust
版本中,这无法编译
:
cpp
error[E0597]: borrowed value does not live long enough
--> src/main.rs:4:14
|
4 | let x = &5;
| ^ does not live long enough
...
10 | }
| - temporary value only lives until here
|
注意:借入的值必须在`静态`生命期内有效...
因为5是局部的,所以它的借用
也是局部
的,这不符合生成要求.
但是,如果在Rust1.21
上编译它,它将起作用.为什么?好吧,如果可把引用数据
放入静
中,可化简为如下let x=&5;
:
cpp
static FIVE: i32 = 5;
let x = &FIVE;
在此,因为FIVE
是静态
的,因此x是&'静态 i32
.
现在生成
代码时并行运行LLVM
.
1.22.0
和1.22.1
稳定版
现在可用Option<T>
!
在Rust1.22
中,Option<T>
现在是稳定
的.此代码现在编译:
cpp
fn add_one_to_first(list: &[u8]) -> Option<u8> {
//如果存在,取第一个元素,如果不存在,则返回`None`
let first = list.get(0)?;
Some(first + 1)
}
assert_eq!(add_one_to_first(&[10, 20, 30]), Some(11));
assert_eq!(add_one_to_first(&[]), None);
现在允许在const
和static
项中,实现Drop
的类型如下:
cpp
struct Foo {
a: u32,
}
impl Drop for Foo {
fn drop(&mut self) {}
}
const F: Foo = Foo { a: 0 };
static S: Foo = Foo { a: 0 };
//常/静
会增强常和静
功能.
现在T op=&T
适合原语类型
:
cpp
let mut x = 2;
let y = &8;
//以前不行,但现在可以了
x += y;
以前,需要写x+=*y
才能解引用
.
1,Box<Error>
现在隐含From<Cow<str>>
2,std::mem::Discriminant
现在保证为发送+同步
3,fs::copy
现在返回NTFS
上主流的长度.
4,正确检测Instant+=Duration
中的溢出.
5,impl Hasher for {&mutHasher,Box<Hasher>}
6,impl fmt::Debug for SplitWhitespace
.