为何Rust程序在不同优化级别下运行表现存在差异？

核心问题是悬垂指针（Dangling Pointer）：

• wide_str!宏内部创建的utf16是栈上的局部数组，当宏执行完毕（块作用域结束），该数组会被销毁，内存被释放或重新利用。
• 返回的指针此时变成悬垂指针，指向已经无效的内存区域。
• 不同优化级别下的表现差异：
  • opt-level = 0：编译器几乎不做优化，栈内存暂时未被覆盖，MessageBox能侥幸读取到正确内容。
  • opt-level = 1/2：编译器会优化栈内存的使用，局部变量销毁后立即重用该内存，导致读取到乱码或无效数据。

需要确保UTF-16字符串的内存生命周期覆盖MessageBoxW的调用过程，以下是两种可行的修复方式：

方式1：使用堆分配的Vec<u16>（推荐，更灵活） #

修改wide_str!宏返回拥有所有权的Vec<u16>，调用MessageBoxW时再获取指针，确保Vec的生命周期足够长：

extern crate alloc;

use std::{
    ffi::{c_char, c_int, c_uint},
    ptr::null_mut,
};

pub enum HWND__ {}
pub type HWND = *mut HWND__;

pub type DWORD = u32;
pub type LPCCH = *const c_char;
pub type LPCWSTR = *const u16;
pub type LPWSTR = *mut u16;
pub type UINT = c_uint;

pub const CP_UTF8: DWORD = 65001;
pub const MB_ERR_INVALID_CHARS: DWORD = 0x08;
pub const MB_OK: UINT = 0x00000000;

macro_rules! wide_str {
    ($($arg:tt)*) => {{
        let utf8 = alloc::fmt::format(format_args!($($arg)*));
        // 先计算所需UTF-16长度
        let len = unsafe {
            MultiByteToWideChar(
                CP_UTF8,
                MB_ERR_INVALID_CHARS,
                utf8.as_ptr() as LPCCH,
                utf8.len() as c_int,
                null_mut(),
                0,
            )
        };
        assert!(len > 0, "error converting utf8 to utf16");
        
        // 分配足够内存（+1用于终止符）
        let mut utf16 = vec![0; len as usize + 1];
        let result = unsafe {
            MultiByteToWideChar(
                CP_UTF8,
                MB_ERR_INVALID_CHARS,
                utf8.as_ptr() as LPCCH,
                utf8.len() as c_int,
                utf16.as_mut_ptr() as LPWSTR,
                utf16.len() as c_int,
            )
        };
        assert!(result != 0, "error converting utf8 to utf16");
        
        utf16
    }};
}

#[link(name = "kernel32")]
extern "system" {
    pub fn MultiByteToWideChar(
        CodePage: UINT,
        dwFlags: DWORD,
        lpMultiByteStr: LPCCH,
        cbMultiByte: c_int,
        lpWideCharStr: LPWSTR,
        cchWideChar: c_int,
    ) -> c_int;
}

#[link(name = "user32")]
extern "system" {
    pub fn MessageBoxW(hWnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT) -> c_int;
}

fn main() {
    unsafe {
        let msg = wide_str!("Message!");
        let caption = wide_str!("Caption!");
        MessageBoxW(
            null_mut(),
            msg.as_ptr(),
            caption.as_ptr(),
            MB_OK,
        );
    }
}

方式2：延长栈上数组的作用域（适合固定长度场景） #

如果坚持使用栈数组，需要将数组的作用域提升到MessageBoxW调用之外，避免提前销毁：

// 类型定义、常量及外部函数声明与原代码一致

macro_rules! wide_str {
    ($buffer:ident, $($arg:tt)*) => {{
        let utf8 = alloc::fmt::format(format_args!($($arg)*));
        let result = unsafe {
            MultiByteToWideChar(
                CP_UTF8,
                MB_ERR_INVALID_CHARS,
                utf8.as_ptr() as LPCCH,
                utf8.len() as c_int,
                $buffer.as_mut_ptr() as LPWSTR,
                $buffer.len() as c_int,
            )
        };
        assert!(result != 0, "error converting utf8 to utf16");
        $buffer.as_ptr()
    }};
}

fn main() {
    unsafe {
        const BUFFER_LEN: usize = 256;
        let mut msg_buffer = [0u16; BUFFER_LEN];
        let msg_ptr = wide_str!(msg_buffer, "Message!");
        
        let mut caption_buffer = [0u16; BUFFER_LEN];
        let caption_ptr = wide_str!(caption_buffer, "Caption!");
        
        MessageBoxW(
            null_mut(),
            msg_ptr,
            caption_ptr,
            MB_OK,
        );
    }
}

悬垂指针是Rust中未定义行为的典型场景，编译器不会为这类问题提供保障，优化级别不同会导致表现差异。修复的核心是保证被指针引用的内存，在指针被使用的整个周期内都处于有效状态。

内容的提问来源于stack exchange，提问作者junglie85