在上一章节的最后我们介绍到利用元组结构体来创建新的类型的方式,在这个章节我们会继续介绍更多态别的应用。
类型的别名
我们在上一个章节,学习到可以利用 type 关键字来替特性定义出其关联类型,而事实上 type 关键字并不一定只能在特性上。我们可以在任意的 scope 下,使用 type 关键字来定义出一个类型的新别名。举例来说:
fn main() {
type Kilometers = i32;
let x: i32 = 5;
let y: Kilometers = 5;
println!("x + y = {}", x + y);
}
以上程序,我们替 i32 类型定义了一个新别名 Kilometers,这个 Kilometers 并不算是一个新的类型,它很单纯地就是代表着 i32 类型。定义新别名主要是用来代替某些需要使用泛型的类型,其在撰写时又臭又长的语法。举例来说:
type Thunk = Box<dyn Fn() + Send + 'static>;
fn main() {
let f: Thunk = Box::new(|| println!("hi"));
}
fn takes_long_type(f: Thunk) {
// --snip--
}
以上程序,我们使用新别名 Thunk 来代替原本的 Box<dyn Fn() + Send + 'static> 类型。
Result<T, E> 枚举也是很常会定义新的别名来代替,因为通常在一个模块下,使用的 Err 变体所包裹的值都是同一个类型。例如标准函数库中的 std::io 模块就会利用 type 关键字替 Result<T, E> 枚举定义出新的别名:
pub struct Error {
repr: Repr,
}
pub type Result<T> = result::Result<T, Error>;
别名也支持泛型,而且也可以搭配 pub 关键字,使别名能够被其它的模块访问。
空类型(Empty Type)
Rust 编程语言还有内置一个十分特别的类型,那就是 !,称作「空类型」。有些函数或是方法,在它们被调用之后,就会进入无穷循环或是使程序直接结束,因此不会有将值回传出去的机会。Rust 编程语言的编译器拥有类型推论的功能,在进行类型推论时,「空类型」的优先权会低于其它的类型,当同时遇到某个表达式可能会回传空类型和其它类型时,便会忽略空类型,将这个表达式的回传值类型推论为其它类型。
举例来说:
fn panic() -> ! {
panic!("panic!!");
}
fn main() {
let status = 5;
let s = if status == 0 {
"Hello World!"
} else {
panic();
};
}
以上代码中,我们定义了一个会回传空类型的 panic 函数,这个函数在调用之后就会使程序 panic,而没有机会将值回传出去。因此程序第 8 行到第 12 行的 if 和 else 关键字组成的表达式,其回传值类型会被推论为 &str。
我们再仔细观察一下 panic 函数的实作方式,就会发现一些特别的地方。既然 panic 函数会回传「空类型」的值的话,那么它势必得在主体中定义回传的动作,即便这个动作可能不会有被运行的机会,也应该还是要有,否则程序应该不能编译才对。难道,panic! 宏有回传值,而且回传值类型就是「空类型」?宾狗!没错,Rust 编程语言有些内置的东西会回传「空类型」,除了能让程序 panic 的相关宏之外,还有 loop 关键字所组成的表达式,在没有 break 关键字的情况下也会回传「空类型」。
可是怎么还是有点奇怪?程序第 2 行,如果我们要让 panic 函数回传 panic! 宏的回传值的话,不是应该不能把它加上分号吗?还有程序第 11 行,我们要让 else 关键字组成的表达式能够回传 panic 函数的回传值的话,不是也应该不能把它加上分号吗?这算是当程序叙述会回传「空类型」时的例外用法,也就是可以无视它有没有分号,只要放在程序区块的最后一行,编译器就会自动判断它需不需要进行回传,如果函数或是方法有定义要回传「空类型」就会回传;如果函数或是方法没有定义回传值类型,就不会回传。
举例来说:
fn panic() -> &'static str {
"panic!!";
}
fn main() {
let status = 5;
let s = if status == 0 {
"Hello World!"
} else {
panic();
};
}
以上程序第 2 行和第 11 行都必须要去掉分号才可以编译成功。
再举一个例子:
fn panic() {
panic!("panic!!")
}
fn main() {
panic();
}
以上代码,虽然 panic! 宏会回传「空类型」,且 panic 函数没有定义回传值类型,但程序第 2 行,即便 panic! 宏没有加上分号也可以编译成功。
动态大小的类型
在先前的章节中,我们学到了动态调度和静态调度,因而了解到 Rust 编程语言要替一个变量或是参数来分配内存空间时,必须要在程序编译时期就要知道要分配多少内存空间,否则就只能是用动态调度的方式,利用参考或是智能型指针来访问数据。
在这边我们来介绍一个相关的特性──Sized。只要是可以在编译阶段就知道其内存空间的类型,都会自动实作 Sized 特性。在使用泛型做静态调度的时候,为了确保泛型类型参数实际所代表的类型是真的能够在程序编译阶段就知道其内存空间,Rust 编程语言其实会自动对泛型类型参数做限制,使它们实际所代表的类型至少要有实作 Sized 特性。
举例来说:
fn generic<T>(t: T) {
// --snip--
}
其实就等于:
fn generic<T: Sized>(t: T) {
// --snip--
}
如果我们要让泛型类型参数不要有实作 Sized 特性的限制,可以用 T: ?Sized 这样的写法来定义。当然,若编译器无法保证 T 泛型类型参数所代表的类型是可以在编译阶段就知道大小的类型的话,就无法使用静态调度了。
fn generic<T: ?Sized>(t: T) {
// --snip--
}
如以上这段程序,参数 t: T 会编译错误。
常数泛型(Const Generics)
在 <> 语法中可以使用 const 关键字来创建可以传入基本数据类型的参数。举个应用例子来说明:
use std::fmt::Debug;
fn print_array<T: Debug, const N: usize>(array: [T; N]) {
println!("{array:?}, size = {N}");
}
fn main() {
let arr = [1, 2, 3];
print_array(arr);
let arr = ["hello", "world"];
print_array(arr);
}
以上程序中,print_array 函数有泛型,且有常数泛型参数 N,用以表示其第一个参数的数组类型的长度。
虽然常数泛型可以这样用,但帮助不大。它最有用的地方是在于它可以在编译阶段的时候去检查常数泛型的数值是否符合某个条件,如下程序:
#![allow(incomplete_features)]
#![feature(generic_const_exprs)]
use std::{
error::Error,
fs::File,
io::{self, Read},
};
// Types used for type-level operations
pub struct Assert<const CHECK: bool>;
pub trait IsTrue {}
impl IsTrue for Assert<true> {}
fn handler<const BUFFER_SIZE: usize>(reader: &mut dyn Read) -> Result<(), io::Error>
where
Assert<{ BUFFER_SIZE % 4 == 0 }>: IsTrue,
Assert<{ BUFFER_SIZE >= 4 }>: IsTrue, {
let mut buffer = [0u8; BUFFER_SIZE];
let c = reader.read(&mut buffer)?;
// do something
Ok(())
}
fn main() -> Result<(), Box<dyn Error>> {
handler::<4096>(&mut File::open("Cargo.toml")?)?;
// handler::<4097>(&mut File::open("Cargo.toml")?)?; // compilation error
Ok(())
}
以上程序,handler 函数可以利用常数泛型参数来设置缓冲空间的大小,并且透过第 17 行和第 18 行的代码将这个缓冲空间大小的数值限制为大于等于 4 的 4 的倍数,如此一来便可以让如程序第 31 行的 handler 函数调用发生编译错误。
不过问题来了,我们何不直接把缓冲空间的大小透过函数参数来传入呢?如以下程序:
use std::{
error::Error,
fs::File,
io::{self, Read},
};
fn handler(reader: &mut dyn Read, buffer_size: usize) -> Result<(), io::Error> {
assert!(buffer_size % 4 == 0 && buffer_size >= 4);
let mut buffer = vec![0u8; buffer_size];
let c = reader.read(&mut buffer)?;
// do something
Ok(())
}
fn main() -> Result<(), Box<dyn Error>> {
handler(&mut File::open("Cargo.toml")?, 4096)?;
handler(&mut File::open("Cargo.toml")?, 4097)?; // panic
Ok(())
}
以上程序虽然也可以运作,但有两个显而易见的缺点:
- 从函数参数传入的缓冲空间大小是在运行阶段才会知道真实数值,因此无法被用来创建堆栈空间,只能够从堆积动态分配空间,堆积的性能是不如堆栈的。
- 无法在编译阶段就阻挡不符合规范的缓冲空间大小。
如何?至此我们就清楚知道常数泛型好用的地方了!
结论
在这个章节我们学会了使用类型的别名和空类型,也了解到泛型类型参数其实会自动有「类型必须实作 Sized 特性」的限制。至此我们已经将 99% 的 Rust 编程语言的观念和规则都学完了,在下一章节,我们就来使用 Rust 编程语言实作出一个支持多线程的 Web 服务器吧!
下一章:创建多线程的 Web 服务器。
