在最一开始的几个章节,我们就已经了解到 Rust 编程语言在编译阶段时,就会进行许多检查,使得程序在通过编译后,进入运行阶段时,能以有效又安全的方式运行。然而,在某些情况下,通常是处理跟操作系统和硬件有关的底层行为时,使用正常能够确保安全性的 Rust 代码并无法实现出我们要的功能,此时就会需要使用到可能会让程序变得不安全的开发方式。

unsafe 关键字,可以使一部份的程序进入不安全模式,在这个模式下,可以直接进行「指针」的解参考、调用不安全的函数或是方法、修改静态变量的值、实作不安全的特性。使用 unsafe 关键字,就是在告诉 Rust 编译器:「我知道自己正在做什么,你不需要管太多。」此时确保程序安全性的责任就在开发者的身上了。

由于使用 unsafe 关键字来开发 Rust 程序可能会遭遇到程序安全性的问题,因此如非必要,尽量不要使用 unsafe 关键字来写程序,但如果不得已一定要用的话,最好精简 unsafe 关键字程序区块中的代码,只把真的需要在不安全模式下才能运行的程序放进去。这样的话,后续如果发现到程序有出现内存泄漏等安全性问题,在查找出问题的代码时,就可以很快地在 unsafe 关键字中,少量的程序叙述区块里,找到发生问题的地方。

「指针」的解参考

在之前的章节中,我们使用参考或是智能型指针,来表示值在内存中的地址。Rust 编程语言可以保证使用参考或是智能型指针指到的内存位置,其保存的数据一定能对应到正确的类型。举例来说,我们无法将 i64 数值的参考,转型成 f64 数值的参考来使用;也无法将 i32 数值的参考,转型成 i64 数值的参考来使用,因为很明显,这两种类型所使用的内存空间大小根本不同,如果 Rust 允许这样的转型,将会去使用到原本就不属于这个数值的内存空间。

但是在 Rust 的不安全模式下,我们可以利用「原始指针」(raw pointer)直接访问内存。原始指针也分为可变和不可变。不可变指针的类型可以写成 *const T,可变指针的类型可以写成 *mut T,T 为其所指到的数据类型,例如 i32 类型的不可变指针就是 *const i32。原始指针忽略拥有权的规则,也因此它没有办法自动消灭其所指到的数据来释放出内存,且它也不保证一定会指到有效的内存空间。

举例来说:

fn main() {
    let mut num = 123i32;

    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;
}

以上程序可以通过编译。没有使用到 unsafe 关键字,只是单纯的创建出 num 变量的不可变指针和可变指针。然而,如果直接尝试对指针进行解参考的动作,程序就会编译失败。例如:

fn main() {
    let mut num = 123i32;

    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;

    println!("{}", *r1);
    println!("{}", *r2);
}

如果我们要进行「指针」的解参考,就必须将代码安置在 unsafe 关键字所形成的程序区块中。例如:

fn main() {
    let mut num = 123i32;

    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;

    unsafe {
        println!("{}", *r1);
        println!("{}", *r2);
    }
}

以上程序才可以编译成功,运行结果如下:

123
123

我们也可以将任意整数类型的值当作是指针来使用,而这个整数值就是内存地址。举例来说:

let address = 0x012345usize;
let r = address as *const i32;

指针的空间大小等同于 isize 或是 usize 类型的空间大小,因此通常会使用 usize 类型来表示指针。

指针可以自由转型成其它类型的指针。举例来说:

fn main() {
    let num = 0x10000000FFFFFFFFi64;
    let r1 = &num as *const i64;
    let r2 = r1 as *const u32;

    unsafe {
        println!("{}", *r1);
        println!("{}", *r2);
    }
}

以上程序运行结果如下:

1152921508901814271
4294967295

调用不安全的函数或是方法

unsafe 关键字也可以放在 fn 关键字之前,使该函数或是方法的主体进入不安全模式。同时,不安全的函数或是方法只有在 Rust 编程语言进入不安全模式的时候才能被调用。

举例来说:

unsafe fn print_something_unsafe() {
    let mut num = 123i32;

    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;

    println!("{}", *r1);
    println!("{}", *r2);
}

fn main() {
    print_something_unsafe();
}

以上程序第 12 行会编译失败,因为 print_something_unsafe 函数是不安全的。如果要让程序可以编译成功,不安全的 print_something_unsafe 函数也必须在不安全模式下才能调用,因此可以将以上程序改写如下:

unsafe fn print_something_unsafe() {
    let mut num = 123i32;

    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;

    println!("{}", *r1);
    println!("{}", *r2);
}

fn main() {
    unsafe {
        print_something_unsafe();
    }
}

使用 unsafe 关键字搭配 fn 关键字,将整个函数或是方法变为不安全的,并不是一个最好的用法。就拿上面这个例子来说,整个 print_something_unsafe 函数其实也只有最后两个程序叙述需要进入不安全模式。因此,将程序改写如下,会是比较好的作法:

fn print_something_unsafe() {
    let mut num = 123i32;

    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;

    unsafe {
        println!("{}", *r1);
        println!("{}", *r2);
    }
}

fn main() {
    print_something_unsafe();
}

Rust 的标准函数库中,有些函数和方法是不安全的,例如 std::slice 模块的 from_raw_parts 和 from_raw_parts_mut 函数。from_raw_parts 函数可以将不可变指针转为数组的不可变参考(切片),from_raw_parts_mut 函数可以将可变指针转为数组的可变参考(切片)。

举一个实际必须应用指针的例子好了。现在我们想要实作一个 split_at 函数,这个函数可以将某个 i32 类型的数组,以指定的索引值为中心,切割成两个数组回传。我们可以写出以下程序:

fn split_at(slice: &[i32], mid: usize) -> (&[i32], &[i32]) {
    let len = slice.len();

    assert!(mid <= len);

    (&slice[..mid], &slice[mid..])
}

那如果我们想要再实作一个 split_at_mut 函数,这个函数与 split_at 函数雷同,只是它改成使用 i32 类型的可变参考的话,要怎么写呢?我们可能会写出以下程序:

fn split_at_mut(slice: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
    let len = slice.len();

    assert!(mid <= len);

    (&mut slice[..mid], &mut slice[mid..])
}

然而,这段程序无法通过编译,因为一个值在一个 scope 下,同时只能有一个可变参考,这是我们之前学到的拥有权规则。为了要能够实作出 split_at_mut 函数,我们可以使用 std::slice 模块提供的不安全的 from_raw_parts_mut 函数来改写程序。如下:

use std::slice;

fn split_at_mut(slice: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
    let len = slice.len();
    let ptr = slice.as_mut_ptr();

    assert!(mid <= len);

    unsafe {
        (
            slice::from_raw_parts_mut(ptr, mid),
            slice::from_raw_parts_mut(ptr.offset(mid as isize), len - mid),
        )
    }
}

切片提供了 as_mut_ptr 方法,可以取得切片的可变指针。可变指针也有提供 offset 方法,可以进行内存位置的位移计算,回传新的指针。由 unsafe 关键字组成的程序叙述区块,整体可以看作是表达式。

Rust 编程语言也将其它编程语言的函数库引用进来使用,而这样的用法是属于不安全的。例如,若要引用某个 C 的函数库提供的 abs 函数,程序如下:

extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    unsafe {
        println!("Absolute value of -3 according to C: {}", abs(-3));
    }
}

修改静态变量的值

先前我们已经学过了 Rust 的常数使用方式,也知道常数可以被声明在任何的 scope,包含全域的 scope。现在要来介绍一个类似常数的东西,那就是「静态变量」(static variable)。常数和静态变量有以下几点的不同:

1. 常数使用 const 关键字来声明,静态变量使用 static 关键字来声明。
2. 常数代表的是值,静态变量代表的是值在内存中的地址。
3. 常数的值可以拷贝,静态变量的值则永远只有那一个。
4. 常数会在程序编译时就会把它对应的值取代至有用到它的程序叙述中,因此可能虽然是使用同样的常数,值却不在相同的内存地址(不同实体)。静态变量的值则会在程序运行的时候保存到内存中,使用相同静态变量时,都是访问相同的内存地址中的值(相同实体)。
5. 常数只有不可变的,静态变量有可变的和不可变的。
6. 常数不能接受静态变量的值,静态变量可以接受常数的值。

访问不可变的静态变量是安全的,举例来说:

static HELLO_WORLD: &str = "Hello, world!";

fn main() {
    println!("name is: {HELLO_WORLD}");
}

以上程序可以通过编译并输出:

name is: Hello, world!

访问可变的静态变量是不安全的,举例来说:

static mut HELLO_WORLD: &str = "Hello, world!";

fn main() {
    println!("name is: {HELLO_WORLD}");
}

以上程序会编译失败,需修改成如下:

static mut HELLO_WORLD: &str = "Hello, world!";

fn main() {
    unsafe {
        println!("name is: {HELLO_WORLD}");
    }
}

实作不安全的特性

除了函数和方法可以加上 unsafe 关键字使其变成不安全的之外,特性也是可以的。加上 unsafe 关键字的特性效果就只是提醒实作这个特性的实作者要谨慎地处理程序,避免发生因实作方式必须进入不安全模式而可能会导致的问题。也就是说,不安全的特性并不是指这个特性的所有函数或是方法都是不安全的,而是实作者必须要适当地使用不安全模式来实作它。而如果要实作不安全的特性的话,在 impl 关键字前也必须要加上 unsafe 关键字。

举例来说:

use std::fmt::Display;

unsafe trait Foo {
    fn print_ptr<T: Display>(&self, p: *const T);
}

struct Bar {}

unsafe impl Foo for Bar {
    fn print_ptr<T: Display>(&self, p: *const T) {
        unsafe {
            println!("{}", *p);
        }
    }
}

fn main() {
    let num = 123i32;
    let r1 = &num as *const i32;

    let b = Bar {};

    b.print_ptr(r1);
}

以上程序,定义了一个 Foo 特性,其有一个 print_ptr 方法,用来印出指针指到的值。由于我们知道,要解参考指针,不管用什么样的方式实作,都必须要让程序进入不安全模式。因此我们认定这个特性必须要谨慎地实作,才不会让程序有安全性上的问题,所以将其加上 unsafe 关键字。这样一来我们自己或是其它 Rust 程序开发者日后若要实作这个 Foo 特性,也必须在 impl 关键字前加上 unsafe 关键字,看到 unsafe 关键字就知道这个特性需要小心谨慎地利用 Rust 编程语言的不安全模式来实作程序了!

结论

透过 unsafe 关键字,代码在不安全模式下就像是有了超能力一样,可以完成平常做不到的事情,也就是直接进行指针的解参考、调用不安全的函数或是方法、修改静态变量的值、实作不安全的特性这四大项目啦!

下一章节,我们将会学习高级的生命周期用法。

下一章:高级的生命周期用法。