Go语言中unsafe.Pointer与函数指针的转换及风险管理

func myFunc(s string) {}

var funcVar func(string) = myFunc // 或者直接定义一个匿名函数变量
ptr := unsafe.Pointer(&funcVar)

var recoveredFunc func(int) bool
recoveredFunc = *(*func(int) bool)(ptr)

package main

import (
    "fmt"
    "unsafe"
)

// 定义两个不同签名的函数
func greet(name string) {
    fmt.Printf("Hello, %s!\n", name)
}

func addOne(num int) int {
    fmt.Printf("Adding one to %d...\n", num)
    return num + 1
}

func main() {
    // 1. 将函数指针转换为unsafe.Pointer并存储
    // 注意：这里我们获取的是存储函数值的变量的地址
    var fGreet func(string) = greet
    var fAddOne func(int) int = addOne

    // 创建一个unsafe.Pointer切片来存储这些函数指针的地址
    pointers := []unsafe.Pointer{
        unsafe.Pointer(&fGreet), // greet 函数变量的地址
        unsafe.Pointer(&fAddOne), // addOne 函数变量的地址
    }

    fmt.Println("--- 原始函数调用 ---")
    fGreet("Alice")
    result := fAddOne(10)
    fmt.Printf("Result of addOne: %d\n\n", result)

    fmt.Println("--- 通过 unsafe.Pointer 转换并调用 ---")

    // 2. 从 unsafe.Pointer 转换回原始类型并调用
    // 转换回 func(string) 类型
    convertedGreet := *(*func(string))(pointers[0])
    fmt.Print("Calling convertedGreet: ")
    convertedGreet("Bob")

    // 转换回 func(int) int 类型
    convertedAddOne := *(*func(int) int)(pointers[1])
    fmt.Print("Calling convertedAddOne: ")
    result = convertedAddOne(20)
    fmt.Printf("Result of convertedAddOne: %d\n\n", result)

    // 3. 从 unsafe.Pointer 转换回一个“不兼容”的函数签名并调用
    // 假设我们将 fAddOne 的 unsafe.Pointer 转换为 func(int) bool 类型
    // 这是一个类型不安全的示例，可能导致运行时错误或不可预测的行为
    fmt.Println("--- 通过 unsafe.Pointer 转换为不同签名并调用 (高风险操作) ---")

    // 注意：fAddOne 的实际签名是 func(int) int
    // 我们现在将其强制转换为 func(int) bool
    // 这意味着在调用时，我们将传递一个 int，并期望返回一个 bool，
    // 但实际执行的是 fAddOne 的逻辑，它返回一个 int。
    // Go运行时可能会尝试将 int 解释为 bool，这通常会导致问题。
    dangerousFunc := *(*func(int) bool)(pointers[1])

    fmt.Print("Calling dangerousFunc with 30 (expecting bool, getting int): ")
    // 尝试调用，这在某些情况下可能导致 panic 或返回非预期值
    // 具体的行为取决于Go运行时如何处理类型不匹配的函数调用约定
    // 在本例中，fAddOne 返回的 int 值可能会被 Go 运行时尝试转换为 bool
    // 通常，非零整数会被视为 true，零被视为 false。但这不应被依赖。
    boolResult := dangerousFunc(30) 
    fmt.Printf("Returned (potentially misinterpreted) bool: %t\n", boolResult) // 31 (int) -> true (bool)

    // 进一步的危险：尝试调用一个完全不兼容的函数签名，例如传递错误数量的参数
    // 这通常会导致运行时 panic: call of nil function value 或者 segmentation fault
    // 警告：以下代码非常危险，可能导致程序崩溃，不建议在生产环境中使用
    //
    // convertedGreetWithWrongSignature := *(*func(int, int, int) int)(pointers[0])
    // fmt.Print("Calling convertedGreetWithWrongSignature (EXTREMELY DANGEROUS): ")
    // _ = convertedGreetWithWrongSignature(1, 2, 3) // 这将导致运行时错误
}