260×260

科学搜查官yuchanns

追寻计算机炼金术的贤者之石
  • Shenzhen, China
  • 后端开发工程师
Posted 7 days ago

Rust类型系统学习笔记

parts of ferris the crab

本文为《Rust编程之道》学习笔记。

友情提示:文中代码可以使用Rust Playground在线运行。

Rust是显式静态强类型的类型安全语言

  • 静态表明它在编译期进行类型检查
  • 强类型表明它不允许类型自动隐式转换,不同类型无法进行计算
  • 类型安全表明它保证运行时的内存安全
  • 显示是因为它的类型推导在某些时候需要显示指定

类型大小

动态大小类型

Rust中大部分类型都可以在编译期确定大小。

对于无法确定大小的类型(即DST, Dynamic Sized Type),只能在运行时分配,使用指针关联。

这样的指针存储了内存地址和长度信息,被称为胖指针

例如&str字符串类型,它是一个引用类型,我们可以获取它指向的地址和长度信息:

fn main() { let str = "yuchanns"; let ptr = str.as_ptr(); let len = str.len(); println!("{:p}", ptr); println!("{:?}", len); } // 0x558706bd2000 // 8

由于存储内存地址和长度的变量类型都为usize(在64位系统上为8字节),所以胖指针可在编译期确定为16字节,分配到栈上。

可以通过下面的代码清单查看胖指针&str的大小:

fn main() { println!("{}", std::mem::size_of::<&str>()); } // 16

需要注意的是,并非所有指针都是胖指针。如果引用的类型大小可以确定,相应的指针大小仅为8字节:

fn main() { // 长度不确定,需要携带长度信息,是胖指针 println!("{}", std::mem::size_of::<&[u32]>()); // 长度确定,是普通指针 println!("{}", std::mem::size_of::<&[u32; 5]>()); } // 16 // 8

零大小类型

单元结构体(struct Foo)、单元类型(())和空枚举(enum Void {})在运行时不占用内存空间(ZSTZero Sized Type)。

在只需要迭代次数的场合中利用Vec<()>可以提高性能。

底类型

!表示无,也可以等同于任何类型。

由于在Rust的流程控制中if属于表达式,两个分支需要返回相同类型的值,在无法返回的情况下可以使用底类型(Bottom Type):

// 该方法死循环,无法返回需要的String类型 fn foo() -> ! { loop {println!("loop");} } fn main() { let msg = if false { foo(); } else { format!("failed") }; println!("{}", msg); }

类型推导

Rust部分情况下可以自动推导类型。

在无法自动推断时需要显式指定类型,帮助编译器确定推导的类型。

fn main() { let x = "1"; assert_eq!(x.parse::<i32>().unwrap(), 1); }

上面的代码清单中,parse::<i32>()这种为泛型函数在<>中标注类型的方式称作Turbofish

泛型

泛型可以节省人编码过程的工作量,提高语言抽象能力。

例如实现两数相加,没有泛型的情况下,我们需要为每个类型实现一遍加法,如fn add_i32(i32, i32) -> i32fn add_i64(i64, i64) -> i64fn add_u32(u32, u32) -> u32fn add_u64(u64, u64) -> u64等。

而有了泛型的帮助,这些类型共用一个fn add<T>(T, T) -> T函数即可。

其中类型T在编译时根据传入的参数类型确定。

如果有多种类型分别调用了该函数,则会在编译期替我们为每个类型实现了一遍加法。

这在Rust中被称为单态化(Monomorphization) ,是零成本抽象的一种,缺点是生成的文件体积会变大。

Trait

Trait为Rust提供了零成本抽象能力。

接口抽象和泛型约束

人们常常在工程中提倡面向接口编程,即定义和实现分离,实现理想的解耦状态。

在Rust中可以使用trait定义接口,然后用impl for进行实现:

trait Shape { fn desc(&self) -> String; } struct Circle {} struct Triangle {} impl Shape for Circle { fn desc(&self) -> String { "this is a circle".to_string() } } impl Shape for Triangle { fn desc(&self) -> String { "this is a triangle".to_string() } } fn get_desc_from_shape<T: Shape>(shape: T) { println!("describe: {:?}", shape.desc()); } fn main() { let c = Circle{} ; let t = Triangle{}; get_desc_from_shape(c); get_desc_from_shape(t); } // describe: "this is a circle" // describe: "this is a triangle"

同时可以看到,函数get_desc_from_shape是通过<T: Shape>来确保入参类型实现了Shape定义,所以Trait还可以为Rust提供泛型约束。

这一机制实现了Ad-hoc多态,又称为函数重载,同样在编译期展开,是零成本抽象。

此外,Trait还通过&dyn提供了非零成本的运行时抽象:

fn get_desc_from_shape_dyn(shape: &dyn Shape) { println!("describe: {:?}", shape.desc()); } fn main() { let c = Circle{}; get_desc_from_shape_dyn(&c); }

trait还可以预先实现方法,节省具体类型的实现工作:

trait ShapePrinter { fn print_shape(&self) { println!("this is a type implemented ShapePrinter"); } } impl ShapePrinter for Circle {} fn print_shape<T: ShapePrinter>(shape: T) { shape.print_shape(); } fn main() { let c = Circle{} ; print_shape(c); }

Trait继承扩展

trait具有继承扩展能力,结合泛型约束可以实现。

例如,我们要为上面小节中所有实现了Shape的结构体扩展ShapePrinter,其实不需要为每个结构体重新实现一遍:

trait ShapePrinter: Shape { fn print_shape(&self) { println!("this is a type implemented ShapePrinter"); } } impl <T: Shape> ShapePrinter for T {} fn main() { let c = Circle{} ; let t = Triangle{}; print_shape(c); print_shape(t); }

通过泛型约束为所有实现了Shape的泛型实现ShapePrinter,只需要写一次,就可以全部实现。

静态分发

如果不结合泛型约束,零成本抽象函数可以通过impl指定静态分发:

fn get_desc_from_shape_static(shape: impl Shape) { println!("describe: {:?}", shape.desc()); } fn main() { let c = Circle{}; get_desc_from_shape_static(c); }

该关键字也可以在返回值中使用,如fn create_shape() -> impl Shape

目前只能在入参和出参使用。

孤儿规则

Rust规定,如果要实现某个trait,那么该trait和要实现的类型至少有一个在当前的crate中定义,即Orphan Rule

该规则保护了标准库和第三方库中定义的类型,避免使用者随意覆盖实现,引发难以预料的Bugs。

关联类型

Associate Types使用type关键字在trait中定义一个泛型,具体类型实现时指定。

关于关联类型的作用,我是参考了Associated Types这篇文章才更好地理解了。

例如下列结构体:

struct Test { name: String, }

我们要定义一个接口,它含有一个test方法,其返回值根据具体实现决定。

使用普通泛型的代码思路:

trait TestB<RHS, S> { fn test(self) -> S; } impl TestB<Self, String> for Test { fn test(self) -> String { format!("{}", self.name) } }

这样在调用时显得怪异而冗长,还会增加理解难度:

// RHS和S是T里使用到的泛型 // 在T作为函数参数时不得不在泛型声明里也写上RHS和S fn test_b<RHS, S, T: TestB<RHS, S>>(t: T) -> S { t.test() }

而使用关联类型的代码:

trait TestA<RHS = Self> { type Output; fn test(self) -> Self::Output; } impl TestA for Test { type Output = String; fn test(self) -> Self::Output { format!("{}", self.name) } }

在实现中直接定义了泛型类型,调用时简洁了很多,也体现了高内聚的工程性:

// 不必写RHS和S,不用关心这个结构体内部声明了多少泛型 fn test<T: TestA>(t: T) -> T::Output { t.test() }

比较糟糕的情况下,如果trait TestA增加了新的泛型,也只需要在实现中指定新的关联类型,而不必每个调用者都跟着追加新的泛型声明,重构影响小。

内置Trait

Rust在标准库中std::marker内置了5个重要的trait,它们分别是:

  • Sized trait:实现了该trait的类型编译期可以确定大小
  • Unsize trait: 实现了该trait的类型大小是动态的
  • Copy trait:实现了该trait的类型可以安全复制
  • Send trait:实现了该trait的类型可以安全地跨线程传递所有权
  • Sync trait:实现了该trait的类型可以安全地跨线程共享引用

其中SendSync保证了Rust在编译期就能排除数据竞争。

内置的trait当然不仅仅是这5个,此处暂且不提。对于内置的trait,可以通过#[derive]派生属性让编译器替用户实现:

#[derive(Debug)] struct Test {} fn main() { println!("{:?}", Test{}); }

例如上面的代码清单中,我们要求编译器为结构体Test派生Debug,那么它就可以被以println!("{:?}", Test{})的形式打印。

类型转换

基本类型转换

Rust可以通过as关键字为基本类型进行转换:

fn main() { let a = 1u32; let b = a as u64; }

需要注意,从长类型转换为短类型,存在被截断的可能。

无歧义完全限定语法

在上面的Trait小节中,细心的读者可能早已发现,一个结构体在实现多个trait时,完全有可能存在同名的方法,调用可能存在歧义。

这时候结合as关键字可以避免歧义:

struct S(i32); trait A { fn test(&self, i: i32) { println!("from A: {:?}", i); } } trait B { fn test(&self, i: i32) { println!("from B: {:?}", i); } } impl A for S {} impl B for S {} fn main() { let s = S(1); <S as A>::test(&s, 1); <S as B>::test(&s, 1); } // from A: 1 // from B: 1

其他转换

结合内置的各种trait,Rust还实现了诸如自动解引用等少数隐式转换.

由于目前学习掌握的信息不足,暂不深入了解,知道即可。