本书github链接：inside-rust-std-library
前面章节参见：
深入RUST标准库内核（序言） - (jianshu.com)
深入RUST标准库内核(一 概述) - (jianshu.com)
深入RUST标准库内核(二 内存）—Layout/原生指针 - (jianshu.com)
深入RUST标准库内核（二 内存）—NonNull
mem模块结构及函数
MaybeUninit
MaybeUninit结构定义
源代码如下：
#[repr(transparent)]
pub union MaybeUninit {
uninit: (),
value: ManuallyDrop,
}
MaybeUninit的内存布局就是ManuallyDrop的内存布局，从后文可以看到，ManuallyDrop实际就是T的内存布局。所以MaybeUninit在内存中实质也就是T类型。
RUST的引用使用的内存块必须保证是内存对齐及赋以初始值，未初始化的内存块和清零的内存块都不能满足引用的条件。但堆内存申请后都是未初始化的，且在程序中某些情况下也需要先将内存设置为未初始化，尤其在处理泛型时。因此，RUST提供了MaybeUninit
MaybeUninit
ManuallyDrop 结构及行为
源代码如下：
#[repr(transparent)]
pub struct ManuallyDrop {
value: T,
}
一个变量被ManuallyDrop获取所有权后，RUST编译器将不再对其自动调用drop操作。需要代码显式的调用drop来释放置入ManuallyDrop的T类型变量。
ManuallyDrop主要使用场景：
- 作为MaybeUninit的内部结构，对未初始化的内存做一个保护和标识。
- 希望由代码显式释放变量时。
重点关注的一些行为：
ManuallyDrop, 此函数返回ManuallyDrop变量拥有传入的T类型变量所有权，并将此块内存直接用ManuallyDrop封装, 对于val，编译器不再主动做drop操作。这里，T实际上应该是实现了Sized的类型
ManuallyDrop, 将封装的T类型变量所有权转移出来，编译器会重新将返回的变量纳入drop管理体系。
ManuallyDrop，实质是复制一个变量。 不影响原有的变量。
ManuallyDrop，手动drop掉内部变量。
ManuallyDrop, 返回内部包装的变量的引用，返回的引用可正常使用
ManuallyDrop返回内部包装的变量的可变引用，返回的引用可正常使用
ManuallyDrop代码举例：
use std::mem::ManuallyDrop;
let mut x = ManuallyDrop::new(String::from("Hello World!"));
x.truncate(5); // 可以对x进行操作
assert_eq!(*x, "Hello");
// 但对x的drop不会再发生
MaybeUninit 行为
MaybeUninit
MaybeUninit, 是MaybeUninit
MaybeUninit, 内部用ManuallyDrop封装了val, 然后用MaybeUninit封装ManuallyDrop。因为如果T没有初始化过，调用这个函数会编译失败，所以此时内存实际上已经初始化过了。
MaybeUninit, 申请了T类型内存并清零。
pub fn zeroed() -> MaybeUninit {
let mut u = MaybeUninit::::uninit();
// SAFETY: `u.as_mut_ptr()` points to allocated memory.
unsafe {
//必须使用write_bytes，否则无法给内存清0
u.as_mut_ptr().write_bytes(0u8, 1);
}
u
}
MaybeUninit,代码如下：
pub const unsafe fn assume_init(self) -> T {
// SAFETY: the caller must guarantee that `self` is initialized.
// This also means that `self` must be a `value` variant.
unsafe {
intrinsics::assert_inhabited::();
//把T的所有权返回，编译器会主动对T调用drop
ManuallyDrop::into_inner(self.value)
}
}
MaybeUninit 此函数最后会调用ptr::read()函数。代码如下：
pub const unsafe fn assume_init_read(&self) -> T {
unsafe {
intrinsics::assert_inhabited::();
//会调用ptr::read
self.as_ptr().read()
}
}
//此函数会复制一个变量，如果类型T含有引用或智能指针，仅仅调用这个函数会可能导致内存重复释放问题，
//但在assume_init_read()中使用此函数不会导致问题，因为src被ManuallyDrop封装，不会被释放。
pub const unsafe fn read(src: *const T) -> T {`
//利用MaybeUninit::uninit申请未初始化的T类型内存
let mut tmp = MaybeUninit::::uninit();
//SAFETY: the caller must guarantee that `src` is valid for reads.
// `src` cannot overlap `tmp` because `tmp` was just allocated on
// the stack as a separate allocated object.
//
// Also, since we just wrote a valid value into `tmp`, it is guaranteed
// to be properly initialized.
unsafe {
//完成内存拷贝
copy_nonoverlapping(src, tmp.as_mut_ptr(), 1);
//初始化后的内存移出ManuallyDrop 并返回
tmp.assume_init()
}
}
可见，assume_init_read 行为实际上是从一个已有类型生成并复制一个新的变量。此时原有的MaybeUninit变量可保持原状。
MaybeUninit 对内部变量进行drop操作
MaybeUninit 返回内部T类型变量的借用，调用者应保证内部T类型变量已经初始化，&T此时是完全正常的
MaybeUninit返回内部T类型变量的可变借用，调用者应保证内部T类型变量已经初始化，&mut T此时是完全正常的
MaybeUninit, 代码如下：
pub const fn write(&mut self, val: T) -> &mut T {
//通常情况下，如果*self是初始化过得，那调用下面的等式时，会立刻调用*self拥有所有权变量的drop。但因为MaybeUninit封装的变量不会被drop。所以下面这个等式实际上隐含了 *self必须是未初始化的，否则的话，这里会丢失掉已初始化的变量所有权信息，可能造成内存泄漏。
*self = MaybeUninit::new(val);
// SAFETY: We just initialized this value.
unsafe { self.assume_init_mut() }
}
MaybeUninit 此处对LEN的使用方式需要注意，这是不常见的一个泛型写法,这个函数同样的申请了一块内存。代码：
pub const fn uninit_array() -> [Self; LEN] {
// SAFETY: An uninitialized `[MaybeUninit<_>; LEN]` is valid.
unsafe { MaybeUninit::<[MaybeUninit; LEN]>::uninit().assume_init() }
}
这里要注意区别数组类型和数组元素的初始化。对于数组[MaybeUninit
MaybeUninit 这个函数没有把所有权转移出来，代码分析如下：
pub unsafe fn array_assume_init(array: [Self; N]) -> [T; N] {
// SAFETY:
// * The caller guarantees that all elements of the array are initialized
// * `MaybeUninit` and T are guaranteed to have the same layout
// * `MaybeUninit` does not drop, so there are no double-frees
// And thus the conversion is safe
unsafe {
//最后是调用是*const T::read()，此处 as *const _的写法可以简化代码,这里没有把T类型变量所有权转移到返回值
//返回后，此MaybeUninit变量应该被丢弃
(&array as *const _ as *const [T; N]).read()
}
}
MaybeUninit
Box的内存申请例子：
pub fn try_new_uninit_in(alloc: A) -> Result, A>, AllocError> {
let layout = Layout::new::>();
//allocate(layout)?返回NonNull<[u8]>, NonNull<[u8]>::>::cast()返回NonNull>
let ptr = alloc.allocate(layout)?.cast();
//以下代码在Box结构时分析
unsafe { Ok(Box::from_raw_in(ptr.as_ptr(), alloc)) }
}
以上代码可以看到，NonNull<[u8]>可以直接通过cast 转换为NonNull
use std::mem::MaybeUninit;
// Create an explicitly uninitialized reference. The compiler knows that data inside
// a `MaybeUninit` may be invalid, and hence this is not UB:
// 获得一个未初始化的i32引用类型内存
let mut x = MaybeUninit::<&i32>::uninit();
// Set it to a valid value.
// 将&0写入变量，完成初始化
x.write(&0);
// Extract the initialized data -- this is only allowed *after* properly
// initializing `x`!
// 将初始化后的变量解封装供后继的代码使用。
let x = unsafe { x.assume_init() };
以上代码，编译器不会对x.write进行报警，这是MaybeUninit
更复杂的例子：
use std::mem::{self, MaybeUninit};
let data = {
// Create an uninitialized array of `MaybeUninit`. The `assume_init` is
// safe because the type we are claiming to have initialized here is a
// bunch of `MaybeUninit`s, which do not require initialization.
// data在声明后实际上就已经初始化完毕。
let mut data: [MaybeUninit>; 1000] = unsafe {
//这里注意实际调用是MaybeUninit::<[MaybeUninit>;1000]>::uninit(), RUST的类型推断机制完成了泛型实例化
MaybeUninit::uninit().assume_init()
};
// Dropping a `MaybeUninit` does nothing. Thus using raw pointer
// assignment instead of `ptr::write` does not cause the old
// uninitialized value to be dropped. Also if there is a panic during
// this loop, we have a memory leak, but there is no memory safety
// issue.
for elem in &mut data[..] {
elem.write(vec![42]);
}
// Everything is initialized. Transmute the array to the
// initialized type.
// 直接用transmute完成整个数组类型的转换
unsafe { mem::transmute::<_, [Vec; 1000]>(data) }
};
assert_eq!(&data[0], &[42]);
下面例子说明一块内存被 MaybeUnint
use std::mem::MaybeUninit;
use std::ptr;
// Create an uninitialized array of `MaybeUninit`. The `assume_init` is
// safe because the type we are claiming to have initialized here is a
// bunch of `MaybeUninit`s, which do not require initialization.
let mut data: [MaybeUninit; 1000] = unsafe { MaybeUninit::uninit().assume_init() };
// 初始化了500个String变量
let mut data_len: usize = 0;
for elem in &mut data[0..500] {
//write没有将所有权转移出ManuallyDrop
elem.write(String::from("hello"));
data_len += 1;
}
// For each item in the array, drop if we allocated it.
//rust不能自动去释放已经申请的String, 必须手工调用drop_in_place释放
for elem in &mut data[0..data_len] {
unsafe { ptr::drop_in_place(elem.as_mut_ptr()); }
}
上例中，在没有assume_init()调用的情况下，必须手工调用drop_in_place释放内存。
MaybeUninit
mem模块函数库
mem::zeroed 此函数用MaybeUninit::zeroed获取全零内存后，调用assume_init(), 返回一个清零的T变量，要确认全零是一种T类型合理的初始化才可用
mem::uninitialized 用MaybeUnint::uninit获取一块未初始化内存，然后调用assume_init(), 此时内存彻底未初始化。
mem::take 将dest设置为默认内容(不改变所有权)，用一个新变量返回dest的内容。
mem::replace 用src的内容赋值dest(不改变所有权)，用一个新变量返回dest的内容。
mem::transmute 直接将T类型内存转化为U类型内存。 类似C语言的&(U *(&src))操作。
mem::transmute_copy 新建类型U的变量，并把src的内容拷贝到U。
mem::forget 通知RUST不做变量的drop操作，代码用ManuallyDrop完成
mem::forget_unsized 代码用intrinsics::forget完成
mem::size_of/mem::min_align_of/mem::size_of_val/mem::min_align_of_val/mem::needs_drop 基本就是直接调用intrinsic模块的同名函数
mem::drop 释放内存
ptr模块再探
ptr::read 此函数用已有的类型复制出一个新的类型实体,对于不支持Copy Trait的类型，read函数是RUST实现未知类型变量的复制的一种方法，此函数作为内存函数take(), replace(), transmute_copy()的基础，底层使用intrisic::copy_no_overlapping支持,代码分析已经在前面章节完成
ptr::read_unaligned当数据结构中有未内存对齐的成员变量时，需要用此函数读取内容并转化为内存对齐的变量。否则会引发UB(undefined behaiver) 如下例：
/// Read a usize value from a byte buffer:
use std::mem;
fn read_usize(x: &[u8]) -> usize {
assert!(x.len() >= mem::size_of::());
let ptr = x.as_ptr() as *const usize;
unsafe { ptr.read_unaligned() }
}
例子中，为了从byte串中读取一个usize，需要用read_unaligned来获取值，不能象C语言那样通过指针类型转换直接获取值。
ptr::write 代码如下：
pub const unsafe fn write(dst: *mut T, src: T) {
unsafe {
//浅拷贝
copy_nonoverlapping(&src as *const T, dst, 1);
//必须调用forget，这里所有权已经转移。不允许再对src做drop操作
intrinsics::forget(src);
}
}
write函数本质上就是一个所有权转移的操作。完成src到dst的浅拷贝，然后调用了forget(src), 这使得src的Drop不再被调用（也规避src类型如果有引用导致的重复释放问题）。从而将所有权转移到dst。此函数是mem::replace， mem::transmute_copy的基础。底层由intrisic:: copy_no_overlapping支持。
这个函数中，如果dst已经初始化过，那原dst变量的所有权将被丢失掉，有可能引发内存泄漏。
pub const fn
replace(dest: &mut T, src: T) -> T {
unsafe {
let result = ptr::read(dest);
ptr::write(dest, src);
result
}
}
上面的函数不会导致内存泄漏问题。因为read本身做了一个已有变量的复制。
ptr::write_unaligned 与read_unaligned相对应。举例如下：
#[repr(packed, C)]
struct Packed {
_padding: u8,
unaligned: u32,
}
let mut packed: Packed = unsafe { std::mem::zeroed() };
// Take the address of a 32-bit integer which is not aligned.
// In contrast to `&packed.unaligned as *mut _`, this has no undefined behavior.
// 对于结构中字节没有按照2幂次对齐的成员，要用addr_of_mut!宏来获得地址，无法用取引用的方式。
let unaligned = std::ptr::addr_of_mut!(packed.unaligned);
unsafe { std::ptr::write_unaligned(unaligned, 42) };
assert_eq!({packed.unaligned}, 42); // `{...}` forces copying the field instead of creating a reference.
ptr::read_volatile 是intrinsics::volatile_load的封装
ptr::write_volatile 是intrinsics::volatiel_store的封装
ptr::macro addr_of($place:expr) 因为用&获得引用必须是字节按照2的幂次对齐的地址，所以用这个宏获取非地址对齐的变量地址
ptr::macro addr_of_mut($place:expr) 作用同上。
指针的通用函数请参考Rust库函数参考
NonNull 与MaybeUninit相关函数
NonNull NonNull与MaybeUninit的引用基本就是直接转换的关系，一体双面
NonNull
NonNull<[T]>::as_uninit_slice<'a>(&self) -> &'a [MaybeUninit
NonNull<[T]>::as_uninit_slice_mut<'a>(&self) -> &'a mut [MaybeUninit
Unique
Unique类型结构定义如下
#[repr(transparent)]
pub struct Unique {
pointer: *const T,
// NOTE: this marker has no consequences for variance, but is necessary
// for dropck to understand that we logically own a `T`.
//
// For details, see:
// https://github.com/rust-lang/rfcs/blob/master/text/0769-sound-generic-drop.md#phantom-data
_marker: PhantomData,
}
和NonNull对比，Unique多了PhantomData
指针在被Unique封装前，必须保证是NonNull的
RUST用Allocator申请出来的内存的所有权用Unique
Unique
//下面的代码前文已经解释过，请参考
pub fn try_new_uninit_in(alloc: A) -> Result, A>, AllocError> {
let layout = Layout::new::>();
let ptr = alloc.allocate(layout)?.cast();
unsafe { Ok(Box::from_raw_in(ptr.as_ptr(), alloc)) }
}
pub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Self {
Box(unsafe { Unique::new_unchecked(raw) }, alloc)
}
以上代码是Box
Unique::cast(self)->Unique 类型转换，程序员应该保证T和U的内存布局相同
Unique:: 此函数内部判断* mut T是否为0值
Unique:: 封装* mut T, 调用代码应该保证* mut T的安全性
Unique::as_ptr(self)->* mut T
Unique::as_ref(&self)->& T 因为Unique具备所有权，此处&T的生命周期与self相同，不必特别声明声明周期
Unique::as_mut(&mut self)->& mut T 同上
所有权转移的底层实现
所有权的转移实际上是两步：1.栈上内存的浅拷贝；2：原先的变量置标志表示所有权已转移。置标志的变量如果没有重新绑定其他变量，则在生命周期结束的时候被drop。 引用及指针自身也是一个isize的值变量，也有所有权，也具备生命周期。
变量调用drop的时机
如下例子：
struct TestPtr {a: i32, b:i32}
impl Drop for TestPtr {
fn drop(&mut self) {
println!("{} {}", self.a, self.b);
}
}
fn main() {
let test = Box::new(TestPtr{a:1,b:2});
let test1 = *test;
let mut test2 = TestPtr{a:2, b:3};
//此行代码会导致先释放test2拥有所有权的变量，然后再给test2赋值。代码后的输出会给出证据
//将test1的所有权转移给test2，无疑代表着test2现有的所有权会在后继无法访问，因此drop被立即调用。
test2 = test1;
println!("{:?}", test2);
}
输出：
2 3
TestPtr { a: 1, b: 2 }
1 2
小结
在RUST标准库的ptr, mem，alloc模块提供了RUST内存的底层操作。内存的底层操作是其他RUST库模块的基础设施。不能理解内存的底层操作，就无法驾驭RUST完成较复杂的任务。