golang 函数作为指针

在Go语言中，函数也是一种数据类型，可以作为指针传递。通过将函数作为指针传递，可以实现更加灵活的函数调用和处理方式。本文将介绍如何使用函数作为指针以及其在Go语言中的应用。

函数指针的定义

在Go语言中，可以使用类型声明来定义一个函数指针。函数指针的定义形式为type 变量名 *func(参数列表) 返回值列表。例如，下面的代码定义了一个接受两个int类型参数并返回int类型值的函数指针：

type IntFuncPtr *func(int, int) int

通过这种方式，我们可以用IntFuncPtr这个类型来声明一个函数指针变量，然后使用该变量来存储函数的地址。

函数指针的传递和调用

函数指针可以作为参数传递给其他函数，并在函数内部进行调用。在调用函数时，可以使用函数指针变量()的形式来调用对应的函数。

下面的代码演示了一个接受函数指针作为参数的函数：

func applyFunc(fnPtr IntFuncPtr, a, b int) int {
    return fnPtr(a, b)
}

func add(a, b int) int {
    return a + b
}

func main() {
    var fnPtr IntFuncPtr
    fnPtr = add
    
    result := applyFunc(fnPtr, 1, 2)
    fmt.Println(result) // 输出：3
}

在上面的代码中，我们先定义了一个applyFunc函数，接受一个IntFuncPtr类型的参数fnPtr，以及两个int类型的参数a和b。在函数内部，通过fnPtr(a, b)的方式调用了对应的函数。

函数指针的应用

函数指针在Go语言中有多种应用场景。下面介绍其中几个常见的应用：

1. 回调函数

函数指针可以用作回调函数，使得程序在满足某些条件时调用指定的函数。

type CallbackFunc func(int)

func callback(fn CallbackFunc, n int) {
    if n > 0 {
        fn(n)
    }
}

func printValue(n int) {
    fmt.Println("Value:", n)
}

func main() {
    callback(printValue, 10) // 输出：Value: 10
}

在上述代码中，我们定义了一个CallbackFunc类型的函数指针fn，以及一个callback函数，它接受一个CallbackFunc类型的参数fn和一个整型参数n。在函数内部，通过fn(n)的方式调用了指定的函数。

2. 排序函数

函数指针可以用于实现自定义的排序函数。通过将比较函数作为参数传递给排序函数，在排序过程中调用指定的比较函数进行元素的比较。

type CompareFunc func(int, int) bool

func bubbleSort(arr []int, cmp CompareFunc) {
    n := len(arr)
    for i := 0; i < n-1; i++ {
        for j := 0; j < n-i-1; j++ {
            if cmp(arr[j], arr[j+1]) {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }
}

func less(a, b int) bool {
    return a < b
}

func greater(a, b int) bool {
    return a > b
}

func main() {
    arr := []int{3, 2, 1, 5, 4}
    
    bubbleSort(arr, less)
    fmt.Println(arr) // 输出：[1 2 3 4 5]
    
    bubbleSort(arr, greater)
    fmt.Println(arr) // 输出：[5 4 3 2 1]
}

在上面的代码中，我们定义了一个CompareFunc类型的函数指针cmp，以及一个bubbleSort函数，它接受一个整型数组arr和一个CompareFunc类型的参数cmp。在函数内部，通过cmp(arr[j], arr[j+1])的方式调用了指定的比较函数，并根据返回值进行元素的交换。

3. 函数封装和代理

函数指针可以用于实现函数的封装和代理，将多个函数封装为一个统一的函数接口进行调用，或者将对某个对象的方法的调用动态代理给其他对象。

type Shape interface {
    Area() float64
}

type Rect struct {
    Width  float64
    Height float64
}

func (r Rect) Area() float64 {
    return r.Width * r.Height
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func printArea(s Shape) {
    fmt.Println("Area:", s.Area())
}

func main() {
    rect := Rect{Width: 2, Height: 3}
    circle := Circle{Radius: 1}
    
    printArea(rect)   // 输出：Area: 6
    printArea(circle) // 输出：Area: 3.141592653589793
}

在上述代码中，我们定义了一个Shape接口，包含一个Area方法，用于计算形状的面积。然后分别定义了Rect和Circle结构体，并实现了Shape接口中的Area方法。在printArea函数中，我们使用Shape类型的参数s来传递不同的形状对象，而无需关心对象的具体类型。

通过将函数作为指针传递，可以灵活地处理函数调用和处理。函数指针在Go语言中有多种应用场景，例如回调函数、排序函数、函数封装和代理等。通过合理运用函数指针，可以提高代码的可读性和可维护性。