Go语言有函数/方法重载吗？

Question

我正在将 C 库移植到 Go。 C 函数（带有可变参数）的定义如下：

curl_easy_setopt(CURL *curl, CURLoption option, ...); 

所以我创建了包装 C 函数：

curl_wrapper_easy_setopt_str(CURL *curl, CURLoption option, char* param);
curl_wrapper_easy_setopt_long(CURL *curl, CURLoption option, long param);

如果我在 Go 中定义函数如下：

func (e *Easy)SetOption(option Option, param string) {
    e.code = Code(C.curl_wrapper_easy_setopt_str(e.curl, C.CURLoption(option), C.CString(param)))
}

func (e *Easy)SetOption(option Option, param long) {
    e.code = Code(C.curl_wrapper_easy_setopt_long(e.curl, C.CURLoption(option), C.long(param)))
}

Go 编译器抱怨：

*Easy·SetOption redeclared in this block

那么 Go 是否支持函数（方法）重载，或者这个错误是否意味着其他含义？

Answer 1

不，事实并非如此。

请参阅 Go 语言常见问题解答，特别是关于 重载。

如果方法分派也不需要进行类型匹配，那么它就会被简化。其他语言的经验告诉我们，使用具有相同名称但不同签名的多种方法有时是有用的，但在实践中也可能会造成混乱和脆弱。仅按名称匹配并要求类型一致是 Go 类型系统中的一个重大简化决策。

更新：2016-04-07

虽然 Go 仍然没有重载函数（可能永远不会），但重载最有用的功能，即使用可选参数调用函数并推断省略参数的默认值，可以使用可变参数函数进行模拟，此后已添加。但这是在类型检查丢失的情况下实现的。

Answer 2

据此，它没有： http://golang.org/doc/go_for_cpp_programmers.html

在概念差异部分中，它说：

Go 不支持函数重载，也不支持用户定义的运算符。

Answer 3

不，Go 没有重载。

重载会增加编译器的复杂性，并且可能永远不会被添加。

正如 Lawrence Dol 提到的，您可以使用可变参数函数，但代价是不进行类型检查。

最好的选择是使用 泛型和类型约束 rel="noreferrer">Go 1.18

为了回答 VityaSchel 的问题，在 Lawrence 的答案的评论中，如何创建一个通用的求和函数，我在下面写了一个。

https://go.dev/play/p/hRhInhsAJFT

package main

import "fmt"

type Number interface {
  int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 | float32 | float64
}

func Sum[number Number](a number, b number) number {
  return a + b
}

func main() {
  var a float64 = 5.1
  var b float64 = 3.2
  println(Sum(a, b))

  var a2 int = 5
  var b2 int = 3
  println(Sum(a2, b2))
}

Answer 4

尽管这个问题确实很老了，但我仍然想说的是，有一种方法可以实现接近重载函数的效果。尽管它可能不会使代码变得如此易于阅读。

假设您想重载函数Test()：

func Test(a int) {
    println(a);
}
func Test(a int, b string) {
    println(a);
    println(b);
}

上面的代码将导致错误。但是，如果您将第一个 Test() 重新定义为 Test1()，将第二个重新定义为 Test2()，并定义一个新函数 Test() 使用 go 的 ...，您将能够以重载的方式调用函数 Test()。
代码：

package main;

func Test1(a int) {
    println(a);
}
func Test2(a int, b string) {
    println(a);
    println(b);
}
func Test(a int, bs ...string) {
    if len(bs) == 0 {
        Test1(a);
    } else {
        Test2(a, bs[0]);
    }
}
func main() {
    Test(1);
    Test(1, "aaa");
}

输出：

1
1
aaa

查看更多信息： https://golangbyexample.com/function-method-overloading -golang/ （我不是这篇链接文章的作者，但我个人认为它很有用）

Answer 5

您还可以通过使用 ...interface{} 使函数可变参数来实现此目的，这将使 param 为 Slice 类型，
然后使用 param[0] 去掉其中的第一个值，

func (e *Easy)SetOption(option Option, param ...interface{}) {
    e.code = Code(C.curl_wrapper_easy_setopt_str(e.curl, C.CURLoption(option), C.CString(param[0])))
}

现在任何类型的参数都是有效的，但以类型检查为代价

Answer 6

正如其他人所说，答案是否定的！

但是 Golang 提供了另一个称为接收器的功能，它可以用来编写接近重载的东西：

基本上，我们使用接收器作为区分函数的一种方式，并且能够<强>对两个不同的函数使用相同的函数名，它们可以具有相同的参数或差异参数，但唯一需要注意的是，您只能使用接收器附加来调用该函数！

我怀疑这种代码是否有用，因为它可能会令人困惑，但尽管如此，它是可能的:)

package main

import "fmt"

type hello struct {
    name string
}

func main() {
    fmt.Println(returnNumber(777))
    h := hello{name: "hello"}
    fmt.Println(h.returnNumber("world"))
}

func returnNumber(i int) int {
    return i
}

func (h hello) returnNumber(s string) string {
    return h.name + s
}