Peut-on avoir des pointeurs de fonction en Aller?

J'apprenais sur les pointeurs en Aller. Et a réussi à écrire quelque chose comme:

func hello(){

       fmt.Println("Hello World")
}

func main(){

       pfunc := hello     //pfunc is a pointer to the function "hello"
       pfunc()            //calling pfunc prints "Hello World" similar to hello function
}

Est-il un moyen de déclarer le pointeur de fonction sans la définir comme fait ci-dessus?
Peut-on écrire quelque chose comme nous le faire en C?

par exemple void (*pfunc)(void);

Je ne sais pas assez sur vais répondre à votre question, mais j'ai un counterquestion: pourquoi voudriez-vous avoir des pointeurs de fonction quand Aller a la bonne première classe de fonctions?
Je suppose que c'est plus une question éducation. J'ai une formation en C et juste commencé à apprendre à propos de Go. J'ai remarqué que Aller a des pointeurs similaire à C et ainsi voulu savoir si des pointeurs de fonction sont possibles en Aller et si oui, comment la déclarer.

InformationsquelleAutor Kevin | 2010-08-30

67

Cela fonctionne si vous êtes en utilisant la signature. Il n'y a pas de pointeur.
```
type HelloFunc func(string)

func SayHello(to string) {
    fmt.Printf("Hello, %s!\n", to)
}

func main() {
    var hf HelloFunc

    hf = SayHello

    hf("world")
}
```
Alternativement, vous pouvez utiliser la fonction de signature directement, sans déclarer un nouveau type.

InformationsquelleAutor themue
32

Aller n'ont pas la même syntaxe pour les pointeurs de fonction comme le C et le C++ n'. Il y a une très bonne explication pour que, sur la Allez blog. Naturellement les Aller auteurs ont pensé que C est la syntaxe pour les pointeurs de fonction trop comme pour les pointeurs, donc en bref, ils ont décidé de faire des pointeurs de fonction explicite; c'est à dire plus lisible.

Voici un exemple que j'ai écrit. Remarquez comment le fp paramètre est défini dans calculate() et l'autre exemple ci-dessous qui vous montre comment vous pouvez faire un pointeur de fonction dans un type et de l'utiliser dans une fonction (le commentaire de calculer la fonction).
```
package main

import "fmt"

type ArithOp func(int, int)int

func main() {
    calculate(Plus)
    calculate(Minus)
    calculate(Multiply)
}

func calculate(fp func(int, int)int) {
    ans := fp(3,2)
    fmt.Printf("\n%v\n", ans) 
}

//This is the same function but uses the type/fp defined above
//
//func calculate (fp ArithOp) {
//    ans := fp(3,2)
//    fmt.Printf("\n%v\n", ans) 
//}

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

func Minus(a, b int) int {
    return a - b
}

func Multiply(a,b int) int {
    return a * b
}
```
La fp paramètre est défini comme une fonction qui prend deux entiers et renvoie un seul int. C'est un peu la même chose Mue mentionné, mais montre un autre exemple d'utilisation.
- Je pense que vous avez mal interpréter ce billet de blog. Il n'est pas de dire que les pointeurs de fonction ne sont pas "autorisés", plutôt qu'ils ont une autre syntaxe de déclaration à la C.
InformationsquelleAutor hannson

Vous pourriez le faire comme ceci:

package main

import "fmt"

func hello(){

       fmt.Println("Hello World")
}

func main(){
       var pfunc func()
       pfunc = hello     //pfunc is a pointer to the function "hello"
       pfunc()            
}

Si votre fonction a des arguments et, par exemple, une valeur de retour, il ressemblerait à:

func hello(name string) int{

       fmt.Println("Hello %s", name)
       return 0
}

et la variable ressemblerait à:

  var pfunc func(string)int

InformationsquelleAutor nos

-1

Une autre approche consiste à définir une interface
```
type command interface {
      DoLoop()
}
```
mettre en œuvre une structure qui met en œuvre
```
type Delete struct {
      instance string
}

func (dev Delete) DoLoop() {
      fmt.Println("input: delete ")
}
```
Créer une carte qui contient la structure
```
 mainFuncTable = make(map[string]command)
 mainFuncTable["delete"] = Delete{"new"}
```
l'appel de la fonction
```
func route(command string) {
      cmd := mainFuncTable[command]
      cmd.DoLoop()
}
```
C'est un peu indirecte, mais il fonctionne
- Je dirais que c'est compliqué de répondre à une question qui a une solution simple.
- En outre, au lieu de faire une structure qui contient une chaîne de caractères, il suffit de créer un nouveau type qui EST une chaîne de caractères: type Delete string et ensuite définir votre interface sur ce nouveau type. Puis string à Delete est juste un type cast: Delete("new"). Et vice-versa.
InformationsquelleAutor Don Newton

Vous devez vous connecter pour publier un commentaire.