mem模块结构及函数
MaybeUninit
MaybeUninit结构定义
源代码如下：
#[repr(transparent)]
pub union MaybeUninit<T> {
uninit: (),
value: ManuallyDrop<T>,
}
MaybeUninit的内存布局就是ManuallyDrop<T>的内存布局，从后文可以看到，ManuallyDrop<T>实际就是T的内存布局。所以MaybeUninit在内存中实质也就是T类型。
RUST的引用使用的内存块必须保证是内存对齐及赋以初始值，未初始化的内存块和清零的内存块都不能满足引用的条件。但堆内存申请后都是未初始化的，且在程序中某些情况下也需要先将内存设置为未初始化，尤其在处理泛型时。因此，RUST提供了MaybeUninit容器来实现对未初始化变量的封装，以便在不引发编译错误完成对T类型未初始化变量的相关操作.
MaybeUninit利用ManuallyDrop的方式对T的未初始化进行了一个标识。这对T也有一个保护，使得未初始化的变量免于被RUST自动调用drop所释放掉.
ManuallyDrop 结构及方法
源代码如下：
#[repr(transparent)]
pub struct ManuallyDrop<T: ?Sized> {
value: T,
}
一个变量被ManuallyDrop获取所有权后，RUST编译器将不再对其自动调用drop操作。需要代码显式的调用drop来释放置入ManuallyDrop的T类型变量。
ManuallyDrop主要使用场景：
- 作为MaybeUninit的内部结构，对未初始化的内存做一个保护和标识。
- 希望由代码显式释放变量时。
重点关注的一些方法：
ManuallyDrop<T>::new（val:T) -> ManuallyDrop<T>, 此函数返回ManuallyDrop变量拥有传入的T类型变量所有权，并将此块内存直接用ManuallyDrop封装, 对于val，编译器不再主动做drop操作。
pub const fn new(value: T) -> ManuallyDrop<T> {
//所有权转移到结构体内部，编译器将忽略这个所有权
ManuallyDrop { value }
}
ManuallyDrop<T>::into_inner(slot: ManuallyDrop<T>)->T, 将封装的T类型变量所有权转移出来，编译器会重新将返回的变量纳入drop管理体系。
pub const fn into_inner(slot: ManuallyDrop<T>) -> T {
//将value解封装，所有权转移到返回值中，编译器重新对所有权做处理
slot.value
}
ManuallyDrop<T>::drop(slot: &mut ManuallyDrop<T>)，手动drop掉内部变量。
ManuallyDrop<T>::deref(&self)-> & T, 返回内部包装的变量的引用
fn deref(&self) -> &T {
//返回后，代码可以用&T对self.value做改动
&self.value
}
ManuallyDrop<T>::deref_mut(&mut self)-> & mut T返回内部包装的变量的可变引用，返回的引用可正常使用
ManuallyDrop代码举例：
use std::mem::ManuallyDrop;
let mut x = ManuallyDrop::new(String::from("Hello World!"));
x.truncate(5); // 此时会调用deref
assert_eq!(*x, "Hello");
// 但对x的drop不会再发生
MaybeUninit 方法
MaybeUninit提供了在GlobalAlloc Trait之外的一种获取内存的方法， 实际上可类比为泛型 new()的一种实现方式,不过返回的不是指针，而是变量。MaybeUninit获取的内存位于栈空间。
MaybeUninit<T>::uninit()->MaybeUninit<T>, 是MaybeUninit栈上申请内存的方法，申请的内存大小是T类型的内存大小，该内存没有初始化。利用泛型和Union内存布局，RUST巧妙的实现了在栈上申请一块未初始化内存。此函数非常非常非常值得关注，是非常多场景下的代码解决方案。
pub const fn uninit() -> MaybeUninit<T> {
//变量内存布局与T类型完全一致
MaybeUninit { uninit: () }
}
MaybeUninit<T>::new(val:T)->MaybeUninit<T>, 内部用ManuallyDrop封装了val, 然后用MaybeUninit封装ManuallyDrop。因为如果T没有初始化过，调用这个函数会编译失败，所以此时内存实际上已经初始化过了。
pub const fn new(val: T) -> MaybeUninit<T> {
//val这个时候是初始化过的。
MaybeUninit { value: ManuallyDrop::new(val) }
}
MaybeUninit<T>::zeroed()->MaybeUninit<T>, 申请了T类型内存并清零。
pub fn zeroed() -> MaybeUninit<T> {
let mut u = MaybeUninit::<T>::uninit();
// SAFETY: `u.as_mut_ptr()` points to allocated memory.
unsafe {
//必须使用write_bytes，否则无法给内存清0
u.as_mut_ptr().write_bytes(0u8, 1);
}
u
}
ManuallyDrop<T>::take(slot: &mut ManuallyDrop<T>)->T，实质是复制一个变量，原变量仍然保留在ManuallyDrop中，但所有权已经转移到复制的变量中，后继不能再调用take或into_inner函数，否则可能会导致悬垂指针的问题。
pub unsafe fn take(slot: &mut ManuallyDrop<T>) -> T {
// 拷贝内部变量，并返回内部变量的所有权
unsafe { ptr::read(&slot.value) }
}
//此函即ptr::read, 会复制一个变量，此时注意，实际上src指向的变量的所有权已经转移给了返回变量，
//所以调用此函数的前提是src的所有权必须有后继处理，例如src本身处于ManallyDrop，或src后继调用forget，
//或给src赋以新的所有权。
//但在assume_init_read()中使用此函数不会导致问题，因为src被ManuallyDrop封装，不会被释放。
pub const unsafe fn read<T>(src: *const T) -> T {`
//利用MaybeUninit::uninit申请未初始化的T类型内存
let mut tmp = MaybeUninit::<T>::uninit();
unsafe {
//完成内存拷贝
copy_nonoverlapping(src, tmp.as_mut_ptr(), 1);
//初始化后的内存移出ManuallyDrop 并返回
tmp.assume_init()
}
}
MaybeUninit<T>::assume_init()->T,代码如下：
pub const unsafe fn assume_init(self) -> T {
// 调用者必须保证self已经初始化了
unsafe {
intrinsics::assert_inhabited::<T>();
//把T的所有权返回，编译器会主动对T调用drop
ManuallyDrop::into_inner(self.value)
}
}
MaybeUninit<T>::assume_init_read()->T 此函数最后会调用ptr::read()函数。代码如下：
pub const unsafe fn assume_init_read(&self) -> T {
unsafe {
intrinsics::assert_inhabited::<T>();
//会调用ptr::read
self.as_ptr().read()
}
}
可见，assume_init_read 方法实际上是从一个已有类型生成并复制一个新的变量。MaybeUninit的变量后继不能再调用assume_init，可能会导致重复drop。
MaybeUninit<T>::assume_init_drop() 对内部变量进行drop操作
MaybeUninit<T>::assume_init_ref()->&T 返回内部T类型变量的借用，调用者应保证内部T类型变量已经初始化，&T此时是完全正常的
MaybeUninit<T>::assume_init_mut()->&mut T返回内部T类型变量的可变借用，调用者应保证内部T类型变量已经初始化，&mut T此时是完全正常的
MaybeUninit<T>::write(val)->&mut T, 代码如下：
pub const fn write(&mut self, val: T) -> &mut T {
//通常情况下，如果*self是初始化过得，那调用下面的等式时，会立刻调用*self拥有所有权变量的drop。但因为MaybeUninit<T>封装的变量不会被drop。所以下面这个等式实际上隐含了 *self必须是未初始化的，否则的话，这里会丢失掉已初始化的变量所有权信息，可能造成内存泄漏。
*self = MaybeUninit::new(val);
// SAFETY: We just initialized this value.
unsafe { self.assume_init_mut() }
}
MaybeUninit<T>::uninit_array<const LEN:usize>()->[Self; LEN] 此处对LEN的使用方式需要注意，这是不常见的一个泛型写法,这个函数同样的申请了一块内存。代码：
pub const fn uninit_array<const LEN: usize>() -> [Self; LEN] {
// SAFETY: An uninitialized `[MaybeUninit<_>; LEN]` is valid.
unsafe { MaybeUninit::<[MaybeUninit<T>; LEN]>::uninit().assume_init() }
}
这里要注意区别数组类型和数组元素的初始化。对于数组[MaybeUninit;LEN]这一类型本身来说，初始化就是确定整体的内存大小，所以数组类型在声明后就已经完成了。所以此时assume_init()是正确的。这是一个理解上的盲点。
MaybeUninit<T>::array_assume_init<const N:usize>(array: [Self; N]) -> [T; N] 这个函数没有把所有权转移出来，代码分析如下：
pub unsafe fn array_assume_init<const N: usize>(array: [Self; N]) -> [T; N] {
// SAFETY:
// * The caller guarantees that all elements of the array are initialized
// * `MaybeUninit<T>` 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一些典型使用代码例子：
use std::mem::MaybeUninit;
// Create an explicitly uninitialized reference. The compiler knows that data inside
// a `MaybeUninit<T>` 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的最重要的应用，这个例子展示了RUST如何给未初始化内存赋值的处理方式。调用assume_init前，必须保证变量已经被正确初始化。
更复杂的例子：
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<Vec<u32>>; 1000] = unsafe {
//这里注意实际调用是MaybeUninit::<[MaybeUninit<Vec<u32>>;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<u32>; 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<String>; 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是一个非常重要的类型结构，未初始化内存是编程中不可避免要遇到的情况，MaybeUninit也就是RUST编程中必须熟练使用的一个类型。