Golang méthodes avec le même nom et arité, mais de type différent

Le code suivant fonctionne très bien. Deux méthodes d'exploitation sur deux différentes structures et l'impression d'un champ de la structure:

type A struct {
  Name string
}

type B struct {
  Name string
}

func (a *A) Print() {
  fmt.Println(a.Name)
}

func (b *B) Print() {
  fmt.Println(b.Name)
}

func main() {

  a := &A{"A"}
  b := &B{"B"}

  a.Print()
  b.Print()
}

Montre la sortie souhaitée dans la console:

A
B

Maintenant, si je change la signature de la méthode de la façon suivante je reçois une erreur de compilation. Je viens de déplacer le récepteur de la méthode pour les arguments de la méthode:

func Print(a *A) {
  fmt.Println(a.Name)
}

func Print(b *B) {
  fmt.Println(b.Name)
}

func main() {

  a := &A{"A"}
  b := &B{"B"}

  Print(a)
  Print(b)
}

Je ne peux même pas compiler le programme:

./test.go:22: Print redeclared in this block
    previous declaration at ./test.go:18
./test.go:40: cannot use a (type *A) as type *B in function argument

Question: Pourquoi est-ce que je peux échange struct types dans le récepteur, mais pas dans le
arguments, quand les méthodes ont le même nom et la même arité?

InformationsquelleAutor Kiril | 2014-05-15
  1. 33

    Parce que Go ne prend pas en charge la surcharge de fonctions définies par l'utilisateur sur leurs types d'argument.

    Vous pouvez faire des fonctions avec des noms différents à la place, ou utiliser des méthodes si vous voulez à la "surcharge" d'un seul paramètre (le récepteur).

    InformationsquelleAutor rightfold
  2. 2

    Vous pouvez utiliser le type de l'introspection. En règle générale, cependant, toute utilisation du générique interface{} type doit être évitée, à moins que vous écrivez un grand cadre générique.

    Cela dit, un couple de façons de la peau le chat proverbial:

    Les deux méthodes supposent un Print() méthode est défini pour les deux types (*A et *B)

    Méthode 1:

    func Print(any interface{}) {
    switch v := any.(type) {
    case *A:
        v.Print()
    case *B:
        v.Print()
    default:
        fmt.Printf("Print() invoked with unsupported type: '%T' (expected *A or *B)\n", any)
        return
    }
}

    Méthode 2:

    type Printer interface {
    Print()
}

func Print(any interface{}) {
    //does the passed value honor the 'Printer' interface
    if v, ok := any.(Printer); ok {
        //yes - so Print()!
        v.Print()
    } else {
        fmt.Printf("value of type %T passed has no Print() method.\n", any)
        return
    }
}

    Si c'est pas souhaitable d'avoir un Print() méthode pour chaque type, définissez ciblées PrintA(*A) et PrintB(*B) fonctions et de modifier la Méthode 1 comme suit:

        case *A:
        PrintA(v)
    case *B:
        PrintB(v)

    De travail aire de jeux exemple ici.

    InformationsquelleAutor colminator