Go语言：利用反射机制校验interface{}参数是否为指针

func f(o *interface{}) {
    // ...
}

package main

import (
    "fmt"
    "reflect"
)

// processPointerArgument 接收一个interface{}类型的参数，并校验它是否为指针。
// 如果不是指针，则会触发panic。
func processPointerArgument(arg interface{}) {
    // 1. 检查参数是否为nil
    // reflect.TypeOf(nil) 会返回nil，但reflect.ValueOf(nil)会返回一个无效的Value。
    // 在某些情况下，直接传入nil会导致TypeOf或ValueOf在后续操作中panic。
    // 更健壮的做法是在反射操作前进行nil检查。
    if arg == nil {
        panic("Error: Argument cannot be nil, expected a pointer.")
    }

    // 2. 获取参数的类型信息
    // reflect.TypeOf(arg) 返回arg所持有的值的静态类型。
    valType := reflect.TypeOf(arg)

    // 3. 检查类型是否为指针
    // Kind() 方法返回类型的基础类别（如 Int, String, Ptr, Struct等）。
    if valType.Kind() != reflect.Ptr {
        panic(fmt.Sprintf("Error: Expected a pointer argument, but received a non-pointer type: %s (%v)", valType.Kind(), valType))
    }

    // 此时，我们已确认arg是一个指针。
    // 可以进一步获取指针指向的值或类型。
    fmt.Printf("Successfully received a pointer to type: %s\n", valType.Elem().String())

    // 示例：如果需要操作指针指向的值
    // val := reflect.ValueOf(arg)
    // if val.IsNil() { // 检查指针本身是否为nil
    //  fmt.Println("Warning: Received a nil pointer (but it's a pointer type).")
    //  return
    // }
    // elem := val.Elem() // 获取指针指向的元素
    // fmt.Printf("Value pointed to: %v (Type: %s)\n", elem, elem.Type())

    // 可以在此进行后续的业务逻辑处理
}

func main() {
    fmt.Println("--- 测试案例 ---")

    // 案例1：传入一个整型指针 (正确)
    var myInt int = 42
    fmt.Println("\n测试1: 传入 &myInt (指向int的指针)")
    func() {
        defer func() {
            if r := recover(); r != nil {
                fmt.Printf("捕获到panic: %v\n", r)
            }
        }()
        processPointerArgument(&myInt)
    }()

    // 案例2：传入一个字符串指针 (正确)
    var myString string = "hello Go"
    fmt.Println("\n测试2: 传入 &myString (指向string的指针)")
    func() {
        defer func() {
            if r := recover(); r != nil {
                fmt.Printf("捕获到panic: %v\n", r)
            }
        }()
        processPointerArgument(&myString)
    }()

    // 案例3：传入一个非指针值 (错误，预期panic)
    var myBool bool = true
    fmt.Println("\n测试3: 传入 myBool (非指针值)")
    func() {
        defer func() {
            if r := recover(); r != nil {
                fmt.Printf("捕获到panic: %v\n", r)
            }
        }()
        processPointerArgument(myBool)
    }()

    // 案例4：传入nil (错误，预期panic)
    fmt.Println("\n测试4: 传入 nil")
    func() {
        defer func() {
            if r := recover(); r != nil {
                fmt.Printf("捕获到panic: %v\n", r)
            }
        }()
        processPointerArgument(nil)
    }()

    // 案例5：传入一个类型化的nil指针 (正确，但指针本身为nil)
    var nilIntPtr *int // 这是一个指针类型，但其值为nil
    fmt.Println("\n测试5: 传入一个类型化的nil指针 (*int)(nil)")
    func() {
        defer func() {
            if r := recover(); r != nil {
                fmt.Printf("捕获到panic: %v\n", r)
            }
        }()
        processPointerArgument(nilIntPtr)
    }()
}