Golang Zeiger

Ich bin derzeit lernen zu Programmieren, Gehen mit Sprache.
Ich habe einige Schwierigkeiten Verständnis Zeiger Gehen (und meine C/C++ ist weit Weg jetzt...).
Bei der Tour von Go #52 (http://tour.golang.org/#52) zum Beispiel, ich lese:

type Vertex struct {
    X, Y float64
}

func (v *Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
    v := &Vertex{3, 4}
    fmt.Println(v.Abs())
}

Aber, wenn anstelle von

func (v *Vertex) Abs() float64 {
[...]
v := &Vertex{3, 4}

Schrieb ich:

func (v Vertex) Abs() float64 {
[...]
v := Vertex{3, 4}

Oder auch:

func (v Vertex) Abs() float64 {
[...]
v := &Vertex{3, 4}

werden, und Umgekehrt:

func (v *Vertex) Abs() float64 {
[...]
v := Vertex{3, 4}

Bekam ich genau das gleiche Ergebnis. Gibt es einen Unterschied (Speicher-Weise, etc.)?

InformationsquelleAutor der Frage merlin Gaillard | 2013-02-26

go pointers

32

Gibt es zwei verschiedene Regeln, die der Sprache Ihrer Beispiele:
1. Ist es möglich abzuleiten, die eine Methode mit einem Zeiger Empfänger eine Methode mit einem Wert-receiver. So func (v Vertex) Abs() float64 generiert automatisch eine zusätzliche Methode Durchführung:
```
func (v Vertex) Abs() float64 { return math.Sqrt(v.X*v.X+v.Y*v.Y) }
func (v *Vertex) Abs() float64 { return Vertex.Abs(*v) }  //GENERATED METHOD
```
  Der compiler findet automatisch die generierte Methode:
```
v := &Vertex{3, 4}
v.Abs()  //calls the generated method
```
2. Gehen können automatisch die Adresse einer variable. In dem folgenden Beispiel:
```
func (v *Vertex) Abs() float64 { return math.Sqrt(v.X*v.X+v.Y*v.Y) }
func main() {
    v := Vertex{3, 4}
    v.Abs()
}
```
  den Ausdruck v.Abs() entspricht dem folgenden code:
```
vp := &v
vp.Abs()
```
InformationsquelleAutor der Antwort
13

Gibt es Unterschiede. Zum Beispiel, die nicht-Zeiger-Empfänger form Kräfte, der Methode mit einer Kopie arbeiten. Die Methode ist nicht in der Lage zu mutieren, die Instanz Sie aufgerufen wurde - ist es nur die Kopie. Das könnte unwirksam sein, z.B. hinsichtlich der Zeit - /Speicher-performance/Verbrauch etc.

OTOH, Zeiger auf Instanzen und Methoden, mit Zeiger-Empfänger ermöglichen eine einfache Beispiel-teilen (und mutiert), wo wünschenswert.

Mehr details hier.

InformationsquelleAutor der Antwort zzzz
2

Der Unterschied ist pass-by-referenve vs pass-by-value.

In func f(v Vertex) das argument ist kopiert in parameter v. In func f(v *Vertex) einen Zeiger auf einen vorhandenen Vertex Instanz übergeben wird.

Beim Einsatz von Methoden, einige der Dereferenzierung kann für Sie getan werden, so können Sie eine Methode func (v *Vertex) f() und nennen Sie es, ohne einen Zeiger zuerst: v := Vertex{...}; v.f(). Dies ist nur ein Körnchen syntax-Zucker, AFAIK.

InformationsquelleAutor der Antwort 9000
0

Gibt es zwei wesentliche Unterschiede in den Beispielen:
```
func (v *Vertex) Abs()....
```
Dem Empfänger werden übergeben durch Referenz für v und Sie wäre in der Lage, rufen Sie diese Methode nur auf Zeiger:
```
v := Vertex{1,3}
v.Abs() //This will result in compile time error
&v.Abs() //But this will work
```
Auf der anderen Seite
```
func (v Vertex) Abs() ....
```
Rufen Sie diese Methode auf Zeigern und Strukturen. Der Empfänger wird passed-by-valueauch wenn Sie diese Methode aufrufen für Zeiger.
```
v := Vertex{1,3}
v.Abs() //This will work, v will be copied.
&v.Abs() //This will also work, v will also be copied.
```
Können Sie erklären beide func (v *Vertex) und func (v Vertex).

InformationsquelleAutor der Antwort ndyakov
0

Als die Spezifikation sagt

Einen Methodenaufruf x.m() ist gültig, wenn die Methode set (Art der) x enthält m und der Liste der Argumente zugewiesen werden können parameter-Listen von m. Wenn x adressierbar ist und &x die Methode set enthält m, x.m() ist die Kurzform (&x).m():

In Ihrem Fall v. Abs() ist die Kurzform für &v. Abs() wenn die Methode adressierbar ist.

InformationsquelleAutor der Antwort Kasinath Kottukkal

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.