前言

上篇结尾谈及了生命周期子类型，本篇就从这里开始。

 

生命周期子类型（lifetime subtyping）

我们可以指定生命周期之间的关系，以指定两个引用是否可以在同一位置使用。继续上一篇Decoder结构体的例子，可以在impl块中指定生命周期之间的关系，如下所示:

// lifetime_subtyping.rs

struct Decoder<'a, 'b, S, R> {
    schema: &'a S,
    reader: &'b R
}

impl<'a, 'b, S, R> Decoder<'a, 'b, S, R>
where 'a: 'b {
    
}

fn main() {
    let a: Vec<u8> = vec![];
    let b: Vec<u8> = vec![];
    let decoder = Decoder {schema: &a, reader: &b};

这里在impl块中使用where子句指定了关系:'a: 'b。意味着a比b生命周期的存在时间要长

 

指定泛型类型的生命周期

除了使用特行来约束泛型函数可以接受的类型之外，还可以使用生命周期注释来约束泛型类型参数。比如，这里有一个logger库，其中logger对象的定义如下:

// lifetime_bounds.rs

enum Level {
    Error
}

struct Logger<'a>(&'a str, Level);

fn configure_logger<T>(_t: T) where T: Send + 'static {
    // configure the logger here
}

fn main() {
    let name = "Global";
    let log1 = Logger(name, Level::Error);
    configure_logger(log1);
}

在以上代码中，有名为Logger的结构体和名为Level的枚举，还有一个名为configure_logger的泛型函数，接收一个类型为T的参数，用Send + 'static进行约束。在main中，我们用'static, 、字符串' Global '创建一个Logger变量，并调用configure_logger进行传参。

看下第9行，除了规定send绑定信息之外，还规定该类型必须与'static生命周期具有相同时间。比如设要使用一个Logger，其引用了一连串更短的生命周期，如下所示：

// lifetime_bounds_short.rs

enum Level {
    Error
}

struct Logger<'a>(&'a str, Level);

fn configure_logger<T>(_t: T) where T: Send + 'static {
    // configure the logger here
}

fn main() {
    let other = String::from("Local");
    let log2 = Logger(&other, Level::Error);
    configure_logger(&log2);
}

编译不会通过，并报错如下：

错误消息明确指出，借用的值必须对静态生命周期有效，但上述代码给它传递了一个字符串过去，该生命周期名为'a，在main函数中 ，比'static的生命周期更短。

要理清这里面的问题，需要看一下Rust中的指针。

 

Rust中的指针类型

不谈指针，有关内存管理的讨论将是不完整的，应该说，指针是所有低级语言中操作内存的主要方式。众所周知，指针只是指向进程地址空间中的内存位置的变量（variables that point to memory locations in the process's address space）。在Rust中， 主要处理三种指针。

 

引用--安全指针（References – safe pointers）

这种指针在借用（borrowing）一节中介绍过，很像C语言中的指针，但是要其正确性需要得到检查，永远不能为null，并且总是会指向任意变量所拥有的数据：所指向的数据要么在栈上，要么在堆上，要么在二进制文件的数据段上。在创建时，会使用到&或者是&mut运算符：这些符号在类型T上作为前缀时，会创建一个引用类型，对于不可变引用，用&T表示，对于可变引用，用&mut表示。让我们再来回顾一下：

• &T: 这是对T类型的一个不可变引用。一个 &T指针是一个Copy类型，这意味着可以有很多对值T的不可变引用。如果把这个赋值给另一个变量，会得到一个指向相同数据的指针的副本。允许创建对一个引用的引用，比如&&T。
• &mut T: 这是对T类型的一个可变引用。在任何范围内，由于借用规则，不能有两个对值T的可变引用。这意味着T类型不实现Copy特性，也不能被发送到线程。

 

原始指针（Raw pointers）

这种指针在类型签名上有一个非常奇怪的标志，会在前缀位置加一个*，而这显然跟接触引用的操作符是一样的。一般而言，原始指针主要用于所谓的非安全代码（unsafe code），需要在一个非安全的区域（unsafe block）来对其解除引用。在Rust中，主要有两种原始指针。

• *const T: 指向类型T的不可变原始指针，为Copy类型，类似于&T，只是*const T可以是null。
• *mut T: 指向值T的可变原始指针，为Non-Copy类型。

需要注意的是，引用可以转换为原始指针，可见如下代码:

let a = &56;
let a_raw_ptr = a as *const u32;
// or
let b = &mut 5634.3;
let b_mut_ptr = b as *mut T;

然而，不能将&T转换为*mut，因为这样会违反只允许一个可变借用的规则。

对于可变引用，可以将其转换为*mut甚至*const T，这被称为指针弱化，也就是说，是从强一点的指针&mut转换为弱一点的*const T指针。对于不可变引用，只能将其转换为*const T。

不难想见，对原始指针进行解除引用是一个不安全的操作，在后续篇章中，会谈一下原始指针的用途。

 

前言

上篇结尾谈及了生命周期子类型，本篇就从这里开始。

 

生命周期子类型（lifetime subtyping）

我们可以指定生命周期之间的关系，以指定两个引用是否可以在同一位置使用。继续上一篇Decoder结构体的例子，可以在impl块中指定生命周期之间的关系，如下所示:

// lifetime_subtyping.rs

struct Decoder<'a, 'b, S, R> {
    schema: &'a S,
    reader: &'b R
}

impl<'a, 'b, S, R> Decoder<'a, 'b, S, R>
where 'a: 'b {
    
}

fn main() {
    let a: Vec<u8> = vec![];
    let b: Vec<u8> = vec![];
    let decoder = Decoder {schema: &a, reader: &b};

这里在impl块中使用where子句指定了关系:'a: 'b。意味着a比b生命周期的存在时间要长

 

指定泛型类型的生命周期

除了使用特行来约束泛型函数可以接受的类型之外，还可以使用生命周期注释来约束泛型类型参数。比如，这里有一个logger库，其中logger对象的定义如下:

// lifetime_bounds.rs

enum Level {
    Error
}

struct Logger<'a>(&'a str, Level);

fn configure_logger<T>(_t: T) where T: Send + 'static {
    // configure the logger here
}

fn main() {
    let name = "Global";
    let log1 = Logger(name, Level::Error);
    configure_logger(log1);
}

在以上代码中，有名为Logger的结构体和名为Level的枚举，还有一个名为configure_logger的泛型函数，接收一个类型为T的参数，用Send + 'static进行约束。在main中，我们用'static, 、字符串' Global '创建一个Logger变量，并调用configure_logger进行传参。

 

看下第9行，除了规定send绑定信息之外，还规定该类型必须与'static生命周期具有相同时间。比如设要使用一个Logger，其引用了一连串更短的生命周期，如下所示：

// lifetime_bounds_short.rs

enum Level {
    Error
}

struct Logger<'a>(&'a str, Level);

fn configure_logger<T>(_t: T) where T: Send + 'static {
    // configure the logger here
}

fn main() {
    let other = String::from("Local");
    let log2 = Logger(&other, Level::Error);
    configure_logger(&log2);
}

编译不会通过，并报错如下：

错误消息明确指出，借用的值必须对静态生命周期有效，但上述代码给它传递了一个字符串过去，该生命周期名为'a，在main函数中 ，比'static的生命周期更短。

要理清这里面的问题，需要看一下Rust中的指针。

 

Rust中的指针类型

不谈指针，有关内存管理的讨论将是不完整的，应该说，指针是所有低级语言中操作内存的主要方式。众所周知，指针只是指向进程地址空间中的内存位置的变量（variables that point to memory locations in the process's address space）。在Rust中， 主要处理三种指针。

 

引用--安全指针（References – safe pointers）

这种指针在借用（borrowing）一节中介绍过，很像C语言中的指针，但是要其正确性需要得到检查，永远不能为null，并且总是会指向任意变量所拥有的数据：所指向的数据要么在栈上，要么在堆上，要么在二进制文件的数据段上。在创建时，会使用到&或者是&mut运算符：这些符号在类型T上作为前缀时，会创建一个引用类型，对于不可变引用，用&T表示，对于可变引用，用&mut表示。让我们再来回顾一下：

• &T: 这是对T类型的一个不可变引用。一个 &T指针是一个Copy类型，这意味着可以有很多对值T的不可变引用。如果把这个赋值给另一个变量，会得到一个指向相同数据的指针的副本。允许创建对一个引用的引用，比如&&T。
• &mut T: 这是对T类型的一个可变引用。在任何范围内，由于借用规则，不能有两个对值T的可变引用。这意味着T类型不实现Copy特性，也不能被发送到线程。

 

原始指针（Raw pointers）

这种指针在类型签名上有一个非常奇怪的标志，会在前缀位置加一个*，而这显然跟接触引用的操作符是一样的。一般而言，原始指针主要用于所谓的非安全代码（unsafe code），需要在一个非安全的区域（unsafe block）来对其解除引用。在Rust中，主要有两种原始指针。

• *const T: 指向类型T的不可变原始指针，为Copy类型，类似于&T，只是*const T可以是null。
• *mut T: 指向值T的可变原始指针，为Non-Copy类型。

 

需要注意的是，引用可以转换为原始指针，可见如下代码:

let a = &56;
let a_raw_ptr = a as *const u32;
// or
let b = &mut 5634.3;
let b_mut_ptr = b as *mut T;

然而，不能将&T转换为*mut，因为这样会违反只允许一个可变借用的规则。

对于可变引用，可以将其转换为*mut甚至*const T，这被称为指针弱化，也就是说，是从强一点的指针&mut转换为弱一点的*const T指针。对于不可变引用，只能将其转换为*const T。

不难想见，对原始指针进行解除引用是一个不安全的操作，在后续篇章中，会谈一下原始指针的用途。

 

结语

本篇介绍了两种指针，下一篇，介绍第三种指针，也就是所谓的智能指针（smart pointer）

 

主要参考和建议读者进一步阅读的文献

https://doc.rust-lang.org/book

深入浅出 Rust，2018，范长春

Rust编程之道，2019， 张汉东

The Complete Rust Programming Reference Guide，2019， Rahul Sharma,Vesa Kaihlavirta,Claus Matzinger

Hands-On Data Structures and Algorithms with Rust，2018，Claus Matzinger

Beginning Rust ，2018，Carlo Milanesi

Rust Cookbook，2017，Vigneshwer Dhinakaran

发布于 22 小时前