Rust 高级编程（Rustonomicon/Rust死灵书）

// A  size_of = 8, align_of = 4
struct A {
    b: u32,
    c:u16,
    a: u8,
}

// A2 size_of = 8, align_of = 4
struct A2 {
    a: u8,
    b: u32,
    c:u16,
}

// A3 size_of = 8, align_of = 4
struct A3 {
    a: u8,
    b: u32,
    c: u16,
    _pad: [u8; 1], // 保证整体类型尺寸是4的倍数
                    // （译注：原文就是“4的倍数”，但似乎“32的倍数”才对）
}

// B  size_of = 2, align_of = 1
struct B {
    a: bool,
    b: i8,
}

// C  size_of = 12, align_of = 4
struct C {
    a: A,
    b: bool,
}

// D<u16, u32>  size_of = 8, align_of = 4
// D<u32, u16>  size_of = 8, align_of = 4
struct D<T, U> {
    count: u16,
    data1: T,
    data2: U,
}

// E  size_of = 0, align_of = 1
struct E {}

// 编译成 struct F { tag: u8}
// F  size_of = 1, align_of = 1
enum F {
    A,
    B,
    C,
}

// 枚举 null 指针优化（优化掉 tag）
// G<&i32>  size_of = 8, align_of = 8
// &i32  size_of = 8, align_of = 8
enum G<T> {
    Some(T),
    None,
}

use std::mem::{size_of, align_of};


trait I {}

struct J {}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn ch02() {

        // println!("H  size_of = {}, align_of = {}", size_of::<H>(), align_of::<H>());
        println!("[i32; 3]  size_of = {}, align_of = {}", size_of::<[i32; 3]>(), align_of::<[i32; 3]>());
        println!("&[i32; 3]  size_of = {}, align_of = {}", size_of::<&[i32; 3]>(), align_of::<&[i32; 3]>());
        // println!("[i32]  size_of = {}, align_of = {}", size_of::<[i32]>(), align_of::<[i32]>());
        println!("&[i32]  size_of = {}, align_of = {}", size_of::<&[i32]>(), align_of::<&[i32]>());

        println!("dyn I  size_of = {}, align_of = {}", size_of::<&dyn I>(), align_of::<&dyn I>());

        println!("J  size_of = {}, align_of = {}", size_of::<J>(), align_of::<J>());
        println!("()  size_of = {}, align_of = {}", size_of::<()>(), align_of::<()>());
        println!("[i32;0]  size_of = {}, align_of = {}", size_of::<[i32;0]>(), align_of::<[i32;0]>());
    }
}

// 如果不允许出现别名，可以进行优化
fn compute(input: &u32, output: &mut u32) {
    if *input > 10 {
        *output = 1;
    }
    if *input > 5 {
        *output *= 2;
    }
}

// 前提条件是不允许出现如下可能性
// compute(&x, &mut x)
fn compute2(input: &u32, output: &mut u32) {
    let cached_input = *input; // 将*input放入缓存
    if cached_input > 10 {
        *output = 1*2; // x > 5 则必然 x > 5，所以直接加倍并立即退出
    } else if cached_input > 5 {
        *output *= 2;
    }
}

fn life(){
    // 例子1
    {
        let x = 0;
        let y = &x;
        let z= &y;
    }
    // 例子1 生命周期展开
    // 'a: {
    //     let x: i32 = 0;
    //     'b: {
    //         // 生命周期是'b，因为这就足够了
    //         let y: &'b i32 = &'b x;
    //         'c: {
    //             // 'c也一样
    //             let z: &'c &'b i32 = &'c y;
    //         }
    //     }
    // }

    // 例子2
    {
        let x = 0;
        let z;
        let y = &x;
        z = y;
    }
    // // 例子2 生命周期展开
    // 'a: {
    //     let x: i32 = 0;
    //     'b: {
    //         let z: &'b i32;
    //         'c: {
    //             // 必须使用'b，因为引用被传递到了'b的作用域
    //             let y: &'b i32 = &'b x;
    //             z = y;
    //         }
    //     }
    // }
}

// fn as_str(data: &u32) -> &str {
//     let s = format!("{}", data);
//     &s // 生命周期错误
// }

// // 生命周期展开分析
// fn as_str<'a>(data: &'a u32) -> &'a str {
//     'b: {
//         let s = format!("{}", data);
//         return &'a s; // 'a > 'b  与现实相悖
//     }
// }

fn life_mut() {
    {
        let mut data = vec![1, 2,3];
        // 以下三句等价：因此在此创建了 data 的不可变引用
        let x = &data[0];
        // let x = Index::index(& data, 0);
        // let data_ref = & data; let x = Index::index(data_ref, 0);

        // 以下两句等价
        // data.push(4); // 如果该语句存在，则在此作用域及父作用域内同时存在一个变量的共享指针和可变指针，所以违反规则
        // let data_mut_ref = &mut data; Vec::push(data_mut_ref, 4);
        println!("{}", x);
    }
    // 生命周期展开分析
    // {
    //     'a: {
    //         let mut data: Vec<i32> = vec![1, 2, 3];
    //         'b: {
    //             // 对于这个借用来说，'b已经足够大了
    //             // （借用只需要在println!中生效即可）
    //             let x: &'b i32 = Index::index::<'b>(&'b data, 0);
    //             'c: {
    //                 // 引入一个临时作用域，因为&mut不需要存在更长时间
    //                 // 在此作用域及父作用域内同时存在一个变量的共享指针和可变指针，所以违反规则
    //                 Vec::push(&'c mut data, e);
    //             }
    //             println!("{}", x);
    //         }
    //     }
    // }

}

fn print(s: &str);                                      // 省略的
fn print<'a>(s: &'a str);                               // 完整的

fn debug(lvl: usize, s: &str);                          // 省略的
fn debug<'a>(lvl: usize, s: &'a str);                   // 完整的

fn substr(s: &str, until: usize) -> &str;               // 省略的
fn substr<'a>(s: &'a str, until: usize) -> &'a str;     // 完整的

fn get_str() -> &str;                                   // 错误

fn frob(s: &str, t: &str) -> &str;                      // 错误

fn get_mut(&mut self) -> &mut T;                        // 省略的
fn get_mut<'a>(&'a mut self) -> &'a mut T;              // 完整的

fn args<T: ToCStr>(&mut self, args: &[T]) -> &mut Command                  // 省略的
fn args<'a, 'b, T: ToCStr>(&'a mut self, args: &'b [T]) -> &'a mut Command;// 完整的

fn new(buf: &mut [u8]) -> BufWriter;                    // 省略的
fn new<'a>(buf: &'a mut [u8]) -> BufWriter<'a>;         // 完整的

fn f<'a>(a: &'a i32, b: &i32, c: &i32, ) -> &'a i32 {
    a
}

    static global_int: u32 = 0;
    fn foo2<'a>() -> &'a u32 {
        return &global_int;         // ok, globals live longer than everything
    }
    let i = foo2();
    let i: &'static u32 = foo2();

    fn foo<'a>(input: *const u32) -> &'a u32 {
        unsafe {
            return &*input
        }
    }
    let x;
    {
        let y = 7;
        x = foo(&y);
    }
    println!("hello: {}", x);

// 高阶函数的生命周期
struct Closure<F> {
    data: (u8, u16),
    func: F
}

impl<F> Closure<F>
    where F: Fn(&(u8, u16)) -> &u8,
{
    fn call(&self) -> &u8 {
        (self.func)(&self.data)
    }
}

// 以上等价于
struct Closure2<F> {
    data: (u8, u16),
    func: F
}

impl<F> Closure2<F>
    where for<'a> F: Fn(&'a (u8, u16)) -> &'a u8, // 高阶 trait 边界（HRTB, Higher-Rank Trait Bounds）
{
    fn call<'a>(&'a self) -> &'a u8 {
        (self.func)(&self.data)
    }
}

fn do_it(data: &(u8, u16)) -> &u8 { &data.0 }

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn ch03() {
        let clo = Closure { data: (0, 1), func: do_it };
        println!("{}", clo.call());
        let clo = Closure2 { data: (0, 1), func: do_it };
        println!("{}", clo.call());
    }
}

struct Slice<'a, T> {
    start: *const T,
    end: *const T,
}

use std::marker::PhantomData;

struct Slice<'a, T: 'a> {
    start: *const T,
    end: *const T,
    phantom: PhantomData<&'a T>,
}

fn borrow_vec<T>(vec: &Vec<T>) -> Slice<'_, T> {
    let ptr = vec.as_ptr();
    Slice {
        start: ptr,
        end: unsafe { ptr.add(vec.len()) },
        phantom: PhantomData,
    }
}

use std::marker::PhantomData;
use std::mem;

struct ExternalResource<R> {
   resource_handle: *mut (),
   resource_type: PhantomData<R>,
}

impl<R: ResType> ExternalResource<R> {
    fn new() -> ExternalResource<R> {
        let size_of_res = mem::size_of::<R>();
        ExternalResource {
            resource_handle: foreign_lib::new(size_of_res),
            resource_type: PhantomData,
        }
    }

    fn do_stuff(&self, param: ParamType) {
        let foreign_params = convert_params(param);
        foreign_lib::do_stuff(self.resource_handle, foreign_params);
    }
}