unsafe Rust 与 FFI¶

// 第5种能力示例：访问 union 字段
union IntOrFloat {
    i: i32,
    f: f32,
}

fn main() {
    let u = IntOrFloat { i: 42 };
    // 读取 union 字段需要 unsafe，因为编译器不知道当前存储的是哪个变体
    // 不变量：调用者必须保证读取的字段与最后写入的字段类型匹配
    let val = unsafe { u.i };
    println!("值: {}", val);
}

fn main() {
    // 安全代码
    let x = 42;

    // unsafe 块：开启超能力
    unsafe {
        // 在这里可以使用四种额外能力
        // 其他安全操作在unsafe块中仍然受编译器检查
    }

    // 回到安全代码
    println!("x = {}", x);
}

// unsafe 函数：调用者需要保证前置条件
unsafe fn dangerous() {
    // 函数体中的所有代码都处于 unsafe 上下文
    println!("这是一个 unsafe 函数");
}

fn main() {
    // 必须在 unsafe 块中调用 unsafe 函数
    unsafe {
        dangerous();
    }
}

// ✅ 场景1：与C库交互（FFI）
extern "C" {
    fn abs(input: i32) -> i32;
}

fn safe_abs(x: i32) -> i32 {
    unsafe { abs(x) } // 必须用 unsafe 调用外部函数
}

// ✅ 场景2：性能关键路径，跳过边界检查
fn get_unchecked_example(slice: &[i32], index: usize) -> i32 {
    assert!(index < slice.len()); // 手动验证安全性
    unsafe { *slice.get_unchecked(index) }
}

// ✅ 场景3：实现底层数据结构
struct MyVec<T> {
    ptr: *mut T,
    len: usize,
    cap: usize,
}

// ✅ 场景4：内联汇编或硬件访问
fn read_cpu_id() -> u64 {
    let result: u64;
    unsafe {
        std::arch::asm!(
            "mov {}, 0",
            out(reg) result,
        );
    }
    result
}

// ❌ 错误：仅为了绕过借用检查器
fn bad_example() {
    let mut data = vec![1, 2, 3];
    let ptr = data.as_mut_ptr();
    // 不应该通过裸指针绕过借用规则
    // unsafe { *ptr = 10; } // 这里有更好的安全替代方案
    data[0] = 10; // ✅ 正确做法
}

// ❌ 错误：仅为了避免 Option/Result 处理
fn bad_unwrap(val: Option<i32>) -> i32 {
    // unsafe { val.unwrap_unchecked() } // 不要这样做
    val.unwrap_or(0) // ✅ 正确做法
}

// ❌ 错误：用transmute转换不相关类型
fn bad_transmute() {
    // let x: f64 = unsafe { std::mem::transmute(42u64) }; // 避免这样做
}

/// 使用 unsafe 的黄金准则：
///
/// 1. 最小化 unsafe 代码范围
/// 2. 在 unsafe 块外提供安全 API
/// 3. 文档化所有安全性不变量（safety invariants）
/// 4. 使用 #[deny(unsafe_op_in_unsafe_fn)] 限制隐式 unsafe
/// 5. 为 unsafe 代码编写充分的测试

// 示例：使用属性强制在 unsafe 函数内显式标注 unsafe 操作
#[deny(unsafe_op_in_unsafe_fn)]
unsafe fn careful_function(ptr: *const i32) -> i32 {
    // 即使在 unsafe fn 内，也需要显式 unsafe 块
    // 这样能更精确地标识哪些操作是 unsafe 的
    unsafe { *ptr }
}

fn main() {
    let x = 42;
    let y = &x as *const i32;       // 不可变裸指针
    let mut z = 10;
    let w = &mut z as *mut i32;      // 可变裸指针

    // 创建裸指针是安全的，解引用是 unsafe 的
    println!("y 指针地址: {:?}", y);
    println!("w 指针地址: {:?}", w);

    unsafe {
        println!("y 指向的值: {}", *y);
        println!("w 指向的值: {}", *w);
        *w = 20; // 通过可变裸指针修改值
        println!("修改后 z = {}", z);
    }
}

fn main() {
    // 裸指针的特性：
    // 1. 允许忽略借用规则，可以同时有可变和不可变指针
    let mut num = 5;
    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;
    // 安全代码中不允许同时有 &num 和 &mut num，但裸指针可以

    // 2. 不保证指向有效内存
    let address = 0x012345usize;
    let _r = address as *const i32; // 可能指向无效内存

    // 3. 允许为空
    let null_ptr: *const i32 = std::ptr::null();
    assert!(null_ptr.is_null());

    // 4. 没有自动清理
    unsafe {
        println!("r1 = {}", *r1);
        println!("r2 = {}", *r2);
    }
}

fn main() {
    let arr = [10, 20, 30, 40, 50];
    let ptr = arr.as_ptr();

    unsafe {
        // offset: 按元素偏移
        for i in 0..5 {
            let val = *ptr.offset(i as isize);
            println!("arr[{}] = {}", i, val);
        }

        // add: 无符号偏移（常用）
        let third = *ptr.add(2);
        println!("第三个元素: {}", third);

        // sub: 反向偏移
        let end_ptr = ptr.add(4);
        let second_last = *end_ptr.sub(1);
        println!("倒数第二个: {}", second_last);
    }
}

use std::mem;

fn main() {
    // 指针类型转换（cast）
    let x: i32 = 42;
    let ptr_i32: *const i32 = &x;
    let ptr_u8: *const u8 = ptr_i32 as *const u8;

    unsafe {
        // 读取 i32 的第一个字节
        println!("第一个字节: {}", *ptr_u8);
    }

    // 使用 cast 方法（更推荐）
    let ptr_u8_v2: *const u8 = ptr_i32.cast::<u8>();

    // 对齐指针
    let data: [u8; 8] = [1, 2, 3, 4, 5, 6, 7, 8];
    let ptr = data.as_ptr();
    let aligned = unsafe { ptr.add(ptr.align_offset(mem::align_of::<u32>())) };
    println!("对齐后的指针: {:?}", aligned);
}

use std::ptr::NonNull;

struct MyBox<T> {
    ptr: NonNull<T>,
}

impl<T> MyBox<T> {
    fn new(val: T) -> Self {
        let boxed = Box::new(val);
        let ptr = Box::into_raw(boxed);
        // NonNull::new_unchecked 要求指针非空（Box保证了这一点）
        MyBox {
            ptr: unsafe { NonNull::new_unchecked(ptr) },
        }
    }

    fn get(&self) -> &T {
        unsafe { self.ptr.as_ref() }
    }

    fn get_mut(&mut self) -> &mut T {
        unsafe { self.ptr.as_mut() }
    }
}

impl<T> Drop for MyBox<T> {
    fn drop(&mut self) {
        unsafe {
            // 从裸指针恢复 Box，让 Box 负责释放内存
            let _ = Box::from_raw(self.ptr.as_ptr());
        }
    }
}

fn main() {
    let mut my_box = MyBox::new(42);
    println!("值: {}", my_box.get());
    *my_box.get_mut() = 100;
    println!("修改后: {}", my_box.get());
}

use std::alloc::{self, Layout};

fn main() {
    // 分配 10 个 i32 的内存
    let layout = Layout::array::<i32>(10).unwrap();

    unsafe {
        // 分配内存
        let ptr = alloc::alloc(layout) as *mut i32;
        if ptr.is_null() {
            alloc::handle_alloc_error(layout);
        }

        // 初始化内存
        for i in 0..10 {
            ptr.add(i).write(i as i32 * 10);
        }

        // 读取
        for i in 0..10 {
            println!("data[{}] = {}", i, *ptr.add(i));
        }

        // 释放内存
        alloc::dealloc(ptr as *mut u8, layout);
    }
}

use std::alloc::{self, Layout};

fn main() {
    unsafe {
        // 分配零初始化内存
        let layout = Layout::array::<u8>(1024).unwrap();
        let ptr = alloc::alloc_zeroed(layout);

        // 验证内存已清零
        for i in 0..1024 {
            assert_eq!(*ptr.add(i), 0);
        }

        // 重新分配（扩容）
        let new_layout = Layout::array::<u8>(2048).unwrap();
        let new_ptr = alloc::realloc(ptr, layout, new_layout.size());
        if new_ptr.is_null() {
            alloc::handle_alloc_error(new_layout);
        }

        // 新区域未初始化，需要手动清零
        std::ptr::write_bytes(new_ptr.add(1024), 0, 1024);

        alloc::dealloc(new_ptr, new_layout);
    }
}

use std::alloc::{GlobalAlloc, Layout, System};
use std::sync::atomic::{AtomicUsize, Ordering};

/// 自定义分配器：追踪内存使用
struct TrackingAllocator {
    inner: System,
    allocated: AtomicUsize,
}

unsafe impl GlobalAlloc for TrackingAllocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        let ptr = unsafe { self.inner.alloc(layout) };
        if !ptr.is_null() {
            self.allocated.fetch_add(layout.size(), Ordering::Relaxed);
        }
        ptr
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        unsafe { self.inner.dealloc(ptr, layout) };
        self.allocated.fetch_sub(layout.size(), Ordering::Relaxed);
    }
}

#[global_allocator]
static ALLOCATOR: TrackingAllocator = TrackingAllocator {
    inner: System,
    allocated: AtomicUsize::new(0),
};

fn main() {
    let before = ALLOCATOR.allocated.load(Ordering::Relaxed);
    let v: Vec<i32> = vec![1, 2, 3, 4, 5];
    let after = ALLOCATOR.allocated.load(Ordering::Relaxed);
    println!("Vec 分配了 {} 字节", after - before);
    drop(v);
    let final_count = ALLOCATOR.allocated.load(Ordering::Relaxed);
    println!("释放后剩余 {} 字节", final_count - before);
}

use std::mem::MaybeUninit;

fn main() {
    // 安全地处理未初始化内存
    let mut data: [MaybeUninit<i32>; 5] = [MaybeUninit::uninit(); 5];

    // 逐个初始化
    for (i, elem) in data.iter_mut().enumerate() {
        elem.write(i as i32 * 10);
    }

    // 转换为已初始化数组
    // 安全性保证：所有元素已被初始化
    let data: [i32; 5] = unsafe {
        // transmute 把 [MaybeUninit<i32>; 5] 转为 [i32; 5]
        std::mem::transmute(data)
    };

    println!("{:?}", data); // [0, 10, 20, 30, 40]
}

// 更安全的方式：使用 assume_init
fn create_array() -> [String; 3] {
    let mut arr: [MaybeUninit<String>; 3] = [
        MaybeUninit::uninit(),
        MaybeUninit::uninit(),
        MaybeUninit::uninit(),
    ];

    arr[0].write(String::from("hello"));
    arr[1].write(String::from("world"));
    arr[2].write(String::from("!"));

    // 使用 map 逐个 assume_init
    arr.map(|x| unsafe { x.assume_init() })
}

// 声明 C 函数签名
extern "C" {
    fn strlen(s: *const std::os::raw::c_char) -> usize;
    fn printf(format: *const std::os::raw::c_char, ...) -> i32;
}

fn main() {
    // CString 确保以 null 结尾
    let c_str = std::ffi::CString::new("Hello, FFI!").unwrap();

    unsafe {
        let len = strlen(c_str.as_ptr());
        println!("C strlen 返回: {}", len);
    }
}

// Rust 与 C 类型对照表
// C 类型        -> Rust 类型
// int           -> std::os::raw::c_int (i32)
// unsigned int  -> std::os::raw::c_uint (u32)
// long          -> std::os::raw::c_long
// char          -> std::os::raw::c_char
// float         -> f32
// double        -> f64
// void*         -> *mut std::os::raw::c_void
// const char*   -> *const std::os::raw::c_char
// size_t        -> usize
// bool          -> bool (C99)

use std::os::raw::{c_char, c_int, c_void};
use std::ffi::{CStr, CString};

extern "C" {
    fn atoi(s: *const c_char) -> c_int;
    fn malloc(size: usize) -> *mut c_void;
    fn free(ptr: *mut c_void);
}

fn safe_atoi(s: &str) -> Option<i32> {
    let c_str = CString::new(s).ok()?;
    Some(unsafe { atoi(c_str.as_ptr()) })
}

fn main() {
    if let Some(num) = safe_atoi("42") {
        println!("解析结果: {}", num);
    }
}

use std::ffi::{CStr, CString};
use std::os::raw::c_char;

fn main() {
    // Rust -> C: 使用 CString
    let rust_string = String::from("Hello from Rust");
    let c_string = CString::new(rust_string).unwrap();
    let c_ptr: *const c_char = c_string.as_ptr();
    // c_ptr 可以传递给 C 函数

    // C -> Rust: 使用 CStr
    unsafe {
        let c_str: &CStr = CStr::from_ptr(c_ptr);
        let rust_str: &str = c_str.to_str().unwrap();
        println!("从 C 指针恢复: {}", rust_str);
    }

    // 注意：CString 拥有内存，CStr 只是借用
    // CString 在 drop 时释放内存
    // 如果 C 函数返回的指针需要由 C 释放，不要用 CString::from_raw
}

// 供 C 代码调用的 Rust 函数
// #[no_mangle] 防止 Rust 编译器修改函数名
// extern "C" 使用 C ABI

/// 计算两个整数的和
///
/// # Safety
/// 此函数通过 FFI 调用，调用者需保证传入有效的 i32 值
#[no_mangle]
pub extern "C" fn rust_add(a: i32, b: i32) -> i32 {
    a + b
}

/// 创建一个字符串并返回指针
/// 调用者需要使用 rust_free_string 释放内存
#[no_mangle]
pub extern "C" fn rust_greeting(name: *const std::os::raw::c_char) -> *mut std::os::raw::c_char {
    let c_str = unsafe {
        assert!(!name.is_null());
        std::ffi::CStr::from_ptr(name)
    };
    let name = c_str.to_str().unwrap_or("World");
    let greeting = format!("Hello, {}!", name);
    std::ffi::CString::new(greeting).unwrap().into_raw()
}

/// 释放 Rust 分配的字符串
///
/// # Safety
/// ptr 必须是由 rust_greeting 返回的有效指针
#[no_mangle]
pub unsafe extern "C" fn rust_free_string(ptr: *mut std::os::raw::c_char) {
    if !ptr.is_null() {
        unsafe {
            let _ = std::ffi::CString::from_raw(ptr);
            // CString 的 drop 会释放内存
        }
    }
}

// build.rs
fn main() {
    // 生成 C 头文件的 Rust 绑定
    let bindings = bindgen::Builder::default()
        .header("wrapper.h")  // C 头文件
        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
        .generate()
        .expect("无法生成绑定");

    // 输出到 $OUT_DIR/bindings.rs
    let out_path = std::path::PathBuf::from(std::env::var("OUT_DIR").unwrap());
    bindings
        .write_to_file(out_path.join("bindings.rs"))
        .expect("无法写入绑定文件");
}

// src/lib.rs - 使用生成的绑定
#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]

// 引入 bindgen 生成的绑定
include!(concat!(env!("OUT_DIR"), "/bindings.rs"));

// 创建安全的 Rust 封装
pub struct SafePoint {
    inner: Point,
}

impl SafePoint {
    pub fn new(x: i32, y: i32) -> Self {
        let inner = unsafe { point_new(x, y) };
        SafePoint { inner }
    }

    pub fn distance(&self, other: &SafePoint) -> f64 {
        unsafe { point_distance(&self.inner, &other.inner) }
    }
}

// build.rs
fn main() {
    let crate_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
    cbindgen::Builder::new()
        .with_crate(crate_dir)
        .with_language(cbindgen::Language::C)
        .generate()
        .expect("无法生成 C 头文件")
        .write_to_file("include/mylib.h");
}

// src/lib.rs - 标注 #[repr(C)] 确保内存布局与 C 兼容

/// 二维向量
#[repr(C)]
pub struct Vec2 {
    pub x: f64,
    pub y: f64,
}

/// 创建新向量
#[no_mangle]
pub extern "C" fn vec2_new(x: f64, y: f64) -> Vec2 {
    Vec2 { x, y }
}

/// 计算向量长度
#[no_mangle]
pub extern "C" fn vec2_length(v: &Vec2) -> f64 {
    (v.x * v.x + v.y * v.y).sqrt()
}

/// 向量相加
#[no_mangle]
pub extern "C" fn vec2_add(a: &Vec2, b: &Vec2) -> Vec2 {
    Vec2 {
        x: a.x + b.x,
        y: a.y + b.y,
    }
}

/// 安全抽象示例：自定义切片分割
///
/// 标准库的 split_at_mut 就是一个安全抽象的典范
fn split_at_mut<T>(slice: &mut [T], mid: usize) -> (&mut [T], &mut [T]) {
    let len = slice.len();
    let ptr = slice.as_mut_ptr();

    // 前置条件检查（在 safe 代码中完成）
    assert!(mid <= len, "mid ({}) > len ({})", mid, len);

    // unsafe 块：仅包含必需的 unsafe 操作
    unsafe {
        (
            std::slice::from_raw_parts_mut(ptr, mid),
            std::slice::from_raw_parts_mut(ptr.add(mid), len - mid),
        )
    }
}

fn main() {
    let mut data = vec![1, 2, 3, 4, 5];
    let (left, right) = split_at_mut(&mut data, 3);
    left[0] = 10;
    right[0] = 40;
    println!("left: {:?}, right: {:?}", left, right);
}

use std::marker::PhantomData;

// 类型状态标记
struct Locked;
struct Unlocked;

/// 保险箱：使用类型状态确保只有解锁后才能读取内容
struct Safe<State> {
    content: String,
    _state: PhantomData<State>,
}

impl Safe<Locked> {
    fn new(content: String) -> Self {
        Safe {
            content,
            _state: PhantomData,
        }
    }

    fn unlock(self, password: &str) -> Result<Safe<Unlocked>, Safe<Locked>> {
        if password == "secret" {
            Ok(Safe {
                content: self.content,
                _state: PhantomData,
            })
        } else {
            Err(self)
        }
    }
}

impl Safe<Unlocked> {
    fn read(&self) -> &str {
        &self.content
    }

    fn lock(self) -> Safe<Locked> {
        Safe {
            content: self.content,
            _state: PhantomData,
        }
    }
}

fn main() {
    let safe = Safe::new("机密文件".to_string());
    // safe.read(); // ❌ 编译错误：Safe<Locked> 没有 read 方法

    match safe.unlock("secret") {
        Ok(unlocked) => {
            println!("内容: {}", unlocked.read()); // ✅ 可以读取
            let _locked = unlocked.lock();
        }
        Err(_) => println!("密码错误"),
    }
}

use std::alloc::{self, Layout};
use std::ptr;

/// 简易的固定大小栈
///
/// # Safety Invariants (安全不变量)
/// - `data` 指向一块已分配的、对齐的、容量为 `capacity` 个 `T` 的内存
/// - `len <= capacity`
/// - `data[0..len]` 中的所有元素均已初始化且有效
/// - `data[len..capacity]` 中的内存未初始化
pub struct FixedStack<T> {
    data: *mut T,
    len: usize,
    capacity: usize,
}

impl<T> FixedStack<T> {
    /// 创建指定容量的栈
    pub fn new(capacity: usize) -> Self {
        assert!(capacity > 0, "容量必须大于0");
        let layout = Layout::array::<T>(capacity).unwrap();
        let data = unsafe { alloc::alloc(layout) as *mut T };
        if data.is_null() {
            alloc::handle_alloc_error(layout);
        }
        FixedStack {
            data,
            len: 0,
            capacity,
        }
    }

    /// 压栈（安全 API）
    pub fn push(&mut self, val: T) -> Result<(), T> {
        if self.len >= self.capacity {
            return Err(val); // 栈满，返回值
        }
        unsafe {
            self.data.add(self.len).write(val);
        }
        self.len += 1;
        Ok(())
    }

    /// 弹栈（安全 API）
    pub fn pop(&mut self) -> Option<T> {
        if self.len == 0 {
            return None;
        }
        self.len -= 1;
        Some(unsafe { self.data.add(self.len).read() })
    }

    /// 查看栈顶
    pub fn peek(&self) -> Option<&T> {
        if self.len == 0 {
            return None;
        }
        Some(unsafe { &*self.data.add(self.len - 1) })
    }

    pub fn len(&self) -> usize {
        self.len
    }

    pub fn is_empty(&self) -> bool {
        self.len == 0
    }
}

impl<T> Drop for FixedStack<T> {
    fn drop(&mut self) {
        // 逐个 drop 元素
        while self.pop().is_some() {}

        // 释放内存
        let layout = Layout::array::<T>(self.capacity).unwrap();
        unsafe {
            alloc::dealloc(self.data as *mut u8, layout);
        }
    }
}

// Safety: FixedStack 独占 data 指向的内存，与 Box<[T]> 的所有权语义一致。
// 如果 T: Send，则 FixedStack<T> 可以安全地跨线程传递。
unsafe impl<T: Send> Send for FixedStack<T> {}
// Safety: FixedStack 只通过 &self 提供只读访问（peek），
// 如果 T: Sync，则多线程只读访问是安全的。
unsafe impl<T: Sync> Sync for FixedStack<T> {}

fn main() {
    let mut stack = FixedStack::new(3);
    stack.push(1).unwrap();
    stack.push(2).unwrap();
    stack.push(3).unwrap();
    assert!(stack.push(4).is_err()); // 栈满

    while let Some(val) = stack.pop() {
        println!("popped: {}", val);
    }
}

/// 自引用结构：一个字段引用另一个字段
/// 这在 Rust 中非常棘手，因为移动会使引用失效

// ❌ 这个结构体无法安全工作
struct SelfRef {
    data: String,
    // ptr 指向 data 的内容，但如果 SelfRef 被移动，ptr 就会悬空
    ptr: *const String,
}

impl SelfRef {
    fn new(data: String) -> Self {
        let mut s = SelfRef {
            data,
            ptr: std::ptr::null(),
        };
        s.ptr = &s.data; // 指向自身
        s
        // ⚠️ 返回时 s 被移动，ptr 变成悬空指针！
    }
}

use std::pin::Pin;
use std::marker::PhantomPinned;

/// 使用 Pin 的自引用结构
struct PinnedSelfRef {
    data: String,
    slice: *const str,
    _pin: PhantomPinned, // 标记为 !Unpin
}

impl PinnedSelfRef {
    fn new(data: String) -> Pin<Box<Self>> {
        let res = PinnedSelfRef {
            data,
            slice: std::ptr::null(),
            _pin: PhantomPinned,
        };
        let mut boxed = Box::pin(res);

        // 初始化自引用
        let slice: *const str = &boxed.data;
        unsafe {
            let mut_ref = Pin::as_mut(&mut boxed);
            Pin::get_unchecked_mut(mut_ref).slice = slice;
        }

        boxed
    }

    fn data(&self) -> &str {
        &self.data
    }

    fn slice(&self) -> &str {
        unsafe { &*self.slice }
    }
}

fn main() {
    let pinned = PinnedSelfRef::new("Hello, Pin!".to_string());
    println!("data: {}", pinned.data());
    println!("slice: {}", pinned.slice());
    // pinned 不能被移动，自引用始终有效
}

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

/// 自定义 Future 示例
struct Delay {
    duration: std::time::Duration,
    started: bool,
}

impl Delay {
    fn new(duration: std::time::Duration) -> Self {
        Delay {
            duration,
            started: false,
        }
    }
}

impl Future for Delay {
    type Output = ();

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        // Pin<&mut Self> 保证 self 不会被移动
        let this = self.get_mut();
        if !this.started {
            this.started = true;
            // 实际实现中会注册定时器
            let waker = cx.waker().clone();
            let duration = this.duration;
            std::thread::spawn(move || {
                std::thread::sleep(duration);
                waker.wake();
            });
            Poll::Pending
        } else {
            Poll::Ready(())
        }
    }
}

use std::pin::pin;

async fn example() {
    let future = async { 42 };

    // pin! 宏将值固定在栈上
    let pinned = pin!(future);

    // pinned 的类型是 Pin<&mut impl Future<Output = i32>>
    // 可以安全地 poll
    println!("Future 已被 pin 到栈上");
}

// 在容器中使用 Pin
fn collect_futures() -> Vec<Pin<Box<dyn Future<Output = i32>>>> {
    vec![
        Box::pin(async { 1 }),
        Box::pin(async { 2 }),
        Box::pin(async { 3 }),
    ]
}

/// Rust 中的未定义行为列表：
/// 1. 解引用悬空指针或空指针
/// 2. 读取未初始化内存
/// 3. 违反别名规则（同时存在可变和不可变引用）
/// 4. 产生无效的基本类型值（如 bool 不是 0 或 1）
/// 5. 数据竞争
/// 6. 解引用未对齐的指针
/// 7. 调用 ABI 不兼容的函数
/// 8. 违反类型的不变量（如 &T 必须对齐且非空）

// 示例：各种 UB
fn ub_examples() {
    // ❌ UB 1: 悬空指针
    let ptr: *const i32 = {
        let x = 42;
        &x as *const i32
    }; // x 已被销毁，ptr 悬空
    // unsafe { println!("{}", *ptr); } // UB!

    // ❌ UB 2: 读取未初始化内存
    // let x: i32;
    // println!("{}", x); // 编译器会阻止，但 unsafe 中可能发生

    // ❌ UB 3: 违反别名规则
    let mut data = vec![1, 2, 3];
    let ptr = data.as_mut_ptr();
    // 同时通过指针和引用访问
    // unsafe { *ptr = 10; }
    // println!("{}", data[0]); // 可能 UB（取决于具体使用方式）

    // ❌ UB 4: 无效的 bool 值
    // let b: bool = unsafe { std::mem::transmute(2u8) }; // UB! bool 只能是 0 或 1
}

fn use_after_free_example() {
    let ptr: *const String;

    {
        let s = String::from("hello");
        ptr = &s as *const String;
        // s 在这里被 drop
    }

    // ❌ ptr 现在是悬空指针
    // unsafe { println!("{}", *ptr); } // use-after-free, UB!
}

// ✅ 安全替代方案
fn safe_alternative() {
    let s = String::from("hello");
    let r: &String = &s; // 借用检查器保证 r 不会比 s 活得久
    println!("{}", r);
}

use std::thread;

// ❌ 数据竞争 UB 示例（概念性代码，不要运行）
fn data_race_example() {
    let mut data = 0u32;
    let ptr = &mut data as *mut u32;

    // 多线程通过裸指针访问同一数据 = 数据竞争
    // let ptr_clone = ptr as usize;
    // thread::spawn(move || {
    //     let p = ptr_clone as *mut u32;
    //     unsafe { *p += 1; } // UB: 数据竞争
    // });
    // unsafe { *ptr += 1; } // UB: 数据竞争
}

// ✅ 安全替代方案：使用原子操作或 Mutex
use std::sync::{Arc, Mutex};

fn safe_concurrent() {
    let data = Arc::new(Mutex::new(0u32));

    let handles: Vec<_> = (0..10)
        .map(|_| {
            let data = Arc::clone(&data);
            thread::spawn(move || {
                let mut guard = data.lock().unwrap();
                *guard += 1;
            })
        })
        .collect();

    for h in handles {
        h.join().unwrap();
    }

    println!("结果: {}", *data.lock().unwrap());
}