Rust 中强制转换为推断函数类型

Question

假设我们有一个FARPROC作为某些Win32操作的结果而收到的类型，例如GetProcAddress. 它的定义如下：

pub type FARPROC = unsafe extern "system" fn() -> isize;

然后需要将该类型转换为有效的函数类型，以便我们可以调用它。作为开发人员，我们知道函数签名（来自文档），但我们需要将这些知识传递给编译器。一种简单的方法是使用transmute显式函数类型，如下所示：

let address: FARPROC = unsafe { GetProcAddress(module, proc).unwrap() };
let function: extern "system" fn(i32) = unsafe { transmute (&address) };

但是，如果我们想从 Rust 代码中定义的现有函数之一推断函数类型怎么办？假设我们有一些定义很长的函数：

pub fn foo(arg1: i32, arg2: c_void, arg3: *const c_char) {
   // snip
}

为了保持我们的代码干燥，是否可以将该函数类型与 一起使用transmute？

我尝试的解决方案如下所示：

pub fn cast_to_function<F>(address: FARPROC, _fn: &F) -> F {
    unsafe { transmute_copy(&address) }
}

/// Usage

let address: FARPROC = unsafe { GetProcAddress(module, proc).unwrap() };
let function = cast_to_function(address, &foo);
function(1, ...);

此尝试的解决方案基于正在运行的类似 C++ 代码：

template<typename T>
T FnCast(void* fnToCast, T pFnCastTo) {
    return (T)fnToCast;
}

/// Usage

void bar(int arg1, void* arg2, const char* arg3){
   // snip
}

auto address = (void*) GetProcAddress(...); 
auto function = FnCast(address, &bar);
function(1, address, "bar");

我在 Rust 中尝试的解决方案的问题是，cast_to_function总是返回具有指向引用函数的地址的函数，而不是指向我们提供的地址。因此，考虑到到目前为止所提出的内容，是否可以从函数的定义中智能地推断出函数类型并将任意类型转换为它？

Answer 1

为了理解为什么你尝试的解决方案不起作用，我们必须了解 Rust 中不同类型的函数类型；看到这个答案。当您拨打此电话时：

let function = cast_to_function(address, &foo);

参数&foo是对特定功能项的引用foo；它不是像 那样的函数指针address。由于 的类型签名cast_to_function()，这意味着返回类型T是相同的函数项。函数项是零大小类型，因此transmute_copy()内部cast_to_function()不执行任何操作。

最简单的解决方案是foo在调用之前转换为函数指针cast_to_function()：

let function = cast_to_function(address, foo as fn(_, _));

（您还需要更改 的cast_to_function()签名以_fn按值获取_fn: F：）。

_尽管如演示的那样，您可以使用占位符 ( ) 而不是写出每个参数类型，但这仍然是手动转换的一些样板。如果参数数量错误，您只会收到编译错误（您不会意外地转换foo为错误的签名）。

摆脱调用者代码中所需的转换更为复杂。我想出了这个解决方案，它使用一个特征来进行转换，并使用一个宏来为不同数量的函数编写实现：

/// Casts a function pointer to a new function pointer, with the new type derived from a
/// template function.
///
/// SAFETY:
/// - `f` must be a function pointer (e.g. `fn(i32) -> i32`)
/// - `template`'s type must be a valid function signature for `f`
unsafe fn fn_ptr_cast<T, U, V>(fn_ptr: T, _template_fn: U) -> V
where
    T: Copy + 'static,
    U: FnPtrCast<V>,
{
    debug_assert_eq!(mem::size_of::<T>(), mem::size_of::<usize>());

    U::fn_ptr_cast(fn_ptr)
}

unsafe trait FnPtrCast<U> {
    unsafe fn fn_ptr_cast<T>(fn_ptr: T) -> U;
}

macro_rules! impl_fn_cast {
    ( $($arg:ident),* ) => {
        unsafe impl<Fun, Out, $($arg),*> FnPtrCast<fn($($arg),*) -> Out> for Fun
        where
            Fun: Fn($($arg),*) -> Out,
        {
            unsafe fn fn_ptr_cast<T>(fn_ptr: T) -> fn($($arg),*) -> Out {
                ::std::mem::transmute(::std::ptr::read(&fn_ptr as *const T as *const *const T))
            }
        }
    }
}

impl_fn_cast!();
impl_fn_cast!(A);
impl_fn_cast!(A, B);
impl_fn_cast!(A, B, C);
impl_fn_cast!(A, B, C, D);
impl_fn_cast!(A, B, C, D, E);
impl_fn_cast!(A, B, C, D, E, F);
impl_fn_cast!(A, B, C, D, E, F, G);
impl_fn_cast!(A, B, C, D, E, F, G, H);

这可以让你做

let function = fn_ptr_cast(address, foo);

无需任何手动铸造。

注意：最后一个解决方案假设函数指针和数据指针大小相同，但在某些平台上情况可能并不总是如此。