Le langage Go possède-t-il une surcharge de fonctions/méthodes ?

Question

Je suis en train de porter une bibliothèque C vers Go. Une fonction C (avec varargs) est définie comme ceci :

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

J'ai donc créé des fonctions C enveloppantes :

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

Si je définis la fonction en Go comme ceci :

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)))
}

Le compilateur Go se plaint :

*Easy·SetOption redeclared in this block

Go prend-il en charge la surcharge des fonctions (méthodes) ou cette erreur a-t-elle une autre signification ?

Answer 1

Non, ce n'est pas le cas.

Voir le FAQ sur le langage Go et plus particulièrement la section sur surcharge .

L'envoi de méthodes est simplifié s'il n'est pas nécessaire d'effectuer une correspondance de type. L'expérience avec d'autres langages nous a montré qu'avoir une variété de méthodes avec le même nom mais des signatures différentes était parfois utile mais que cela pouvait aussi être confus et fragile en pratique. La correspondance uniquement par nom et l'exigence de cohérence dans les types a été une décision de simplification majeure dans le système de types de Go.

Mise à jour : 2016-04-07

Alors que Go n'a toujours pas de fonctions surchargées (et n'en aura probablement jamais), la caractéristique la plus utile de la surcharge, celle d'appeler une fonction avec des arguments optionnels et de déduire les valeurs par défaut pour ceux qui sont omis, peut être simulée en utilisant une fonction variadique, qui a été ajoutée depuis. Mais cela se fait au détriment de la vérification de type.

Par exemple : http://changelog.ca/log/2015/01/30/golang

Answer 2

Selon ce document, ce n'est pas le cas : http://golang.org/doc/go_for_cpp_programmers.html

Dans le Différences conceptuelles section, il est dit :

"Go ne supporte pas la surcharge de fonctions et ne supporte pas les opérateurs définis par l'utilisateur".

Answer 3

Même si cette question est très ancienne, je tiens à dire qu'il existe un moyen d'obtenir quelque chose de proche de la surcharge des fonctions. Même si cela ne rend pas le code aussi facile à lire.

Disons que si vous voulez surcharger la fonction Test() :

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

Le code ci-dessus provoquera une erreur. Cependant, si vous redéfinissez le premier Test() à Test1() et le second à Test2() et définir une nouvelle fonction Test() en utilisant les go's ... vous serez en mesure d'appeler la fonction Test() la façon dont il est surchargé. code :

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");
}

sortie :

1
1
aaa

voir plus à : https://golangbyexample.com/function-method-overloading-golang/

Answer 4

Golang 1.18 dispose maintenant de la surcharge des fonctions : https://go.dev/doc/tutorial/generics

Answer 5

func (e *Easy)SetOption(any []interface{})

Le processus convertit les paramètres en ceci : vide. interface{} .

Le premier type de conversion, puis les processus logiques internes.

http://zerousm99.blogspot.kr/2015/01/golang-overload.html