Go
puntatori

Sintassi

• pointer: = & variable // ottiene il puntatore dalla variabile
• variabile: = * puntatore // ottiene la variabile dal puntatore
• * pointer = value // imposta il valore dalla variabile attraverso il puntatore
• pointer: = new (Struct) // ottiene il puntatore della nuova struttura

Puntatori di base

Go supporta i puntatori , consentendo di passare riferimenti a valori e record all'interno del programma.

package main

import "fmt"

// We'll show how pointers work in contrast to values with
// 2 functions: `zeroval` and `zeroptr`. `zeroval` has an
// `int` parameter, so arguments will be passed to it by
// value. `zeroval` will get a copy of `ival` distinct
// from the one in the calling function.
func zeroval(ival int) {
    ival = 0
}

// `zeroptr` in contrast has an `*int` parameter, meaning
// that it takes an `int` pointer. The `*iptr` code in the
// function body then _dereferences_ the pointer from its
// memory address to the current value at that address.
// Assigning a value to a dereferenced pointer changes the
// value at the referenced address.
func zeroptr(iptr *int) {
    *iptr = 0
}

Una volta definite queste funzioni, puoi fare quanto segue:

func main() {
    i := 1
    fmt.Println("initial:", i) // initial: 1

    zeroval(i)
    fmt.Println("zeroval:", i) // zeroval: 1
    // `i` is still equal to 1 because `zeroval` edited
    // a "copy" of `i`, not the original.

    // The `&i` syntax gives the memory address of `i`,
    // i.e. a pointer to `i`. When calling `zeroptr`,
    // it will edit the "original" `i`.
    zeroptr(&i)
    fmt.Println("zeroptr:", i) // zeroptr: 0

    // Pointers can be printed too.
    fmt.Println("pointer:", &i) // pointer: 0x10434114
}

Prova questo codice

Puntatore v. Metodi di valore

Metodi di puntamento

I metodi di puntatore possono essere chiamati anche se la variabile non è essa stessa un puntatore.

Secondo la specifica Go ,

. . . un riferimento a un metodo non-interface con un ricevitore puntatore che usa un valore indirizzabile prenderà automaticamente l'indirizzo di quel valore: t.Mp è equivalente a (&t).Mp .

Puoi vedere questo in questo esempio:

package main

import "fmt"

type Foo struct {
    Bar int
}

func (f *Foo) Increment() {
    f.Bar += 1
}

func main() {
    var f Foo

    // Calling `f.Increment` is automatically changed to `(&f).Increment` by the compiler.
    f = Foo{}
    fmt.Printf("f.Bar is %d\n", f.Bar)
    f.Increment()
    fmt.Printf("f.Bar is %d\n", f.Bar)
    
    // As you can see, calling `(&f).Increment` directly does the same thing.
    f = Foo{}
    fmt.Printf("f.Bar is %d\n", f.Bar)
    (&f).Increment()
    fmt.Printf("f.Bar is %d\n", f.Bar)
}

Gioca

Metodi di valore

Analogamente ai metodi puntatori, i metodi di valore possono essere chiamati anche se la variabile non è essa stessa un valore.

Secondo la specifica Go ,

. . . un riferimento a un metodo non-interface con un ricevitore di valore che utilizza un puntatore automaticamente pt.Mv quel puntatore: pt.Mv è equivalente a (*pt).Mv .

Puoi vedere questo in questo esempio:

package main

import "fmt"

type Foo struct {
    Bar int
}

func (f Foo) Increment() {
    f.Bar += 1
}

func main() {
    var p *Foo

    // Calling `p.Increment` is automatically changed to `(*p).Increment` by the compiler.
    // (Note that `*p` is going to remain at 0 because a copy of `*p`, and not the original `*p` are being edited)
    p = &Foo{}
    fmt.Printf("(*p).Bar is %d\n", (*p).Bar)
    p.Increment()
    fmt.Printf("(*p).Bar is %d\n", (*p).Bar)
    
    // As you can see, calling `(*p).Increment` directly does the same thing.
    p = &Foo{}
    fmt.Printf("(*p).Bar is %d\n", (*p).Bar)
    (*p).Increment()
    fmt.Printf("(*p).Bar is %d\n", (*p).Bar)
}

Gioca

Per ulteriori informazioni sui metodi di puntatore e valore, visitare la sezione Vai specifiche su Valori metodo o consultare la sezione Effettiva Vai su Puntatori v. Valori .

Nota 1: La parentesi ( () ) attorno a *p e &f prima di selettori come .Bar sono lì per scopi di raggruppamento e devono essere mantenuti.

Nota 2: Sebbene i puntatori possano essere convertiti in valori (e viceversa) quando sono i ricevitori di un metodo, non vengono convertiti automaticamente a vicenda quando sono argomenti all'interno di una funzione.

Puntatori di dereferenziamento

I puntatori possono essere dereferenziati aggiungendo un asterisco * prima di un puntatore.

package main

import (
    "fmt"
)

type Person struct {
    Name string
}

func main() {
    c := new(Person) // returns pointer
    c.Name = "Catherine"
    fmt.Println(c.Name) // prints: Catherine
    d := c
    d.Name = "Daniel"
    fmt.Println(c.Name) // prints: Daniel
    // Adding an Asterix before a pointer dereferences the pointer
    i := *d
    i.Name = "Ines"
    fmt.Println(c.Name) // prints: Daniel
    fmt.Println(d.Name) // prints: Daniel
    fmt.Println(i.Name) // prints: Ines
}

Le fette sono puntatori ai segmenti dell'array

Le slice sono puntatori agli array, con la lunghezza del segmento e la sua capacità. Si comportano come puntatori e assegnando il loro valore a un'altra fetta assegneranno l'indirizzo di memoria. Per copiare un valore di slice su un altro, utilizzare la funzione di copia incorporata: func copy(dst, src []Type) int (restituisce la quantità di elementi copiati).

package main

import (
    "fmt"
)

func main() {
    x := []byte{'a', 'b', 'c'}
    fmt.Printf("%s", x)       // prints: abc
    y := x
    y[0], y[1], y[2] = 'x', 'y', 'z'
    fmt.Printf("%s", x)       // prints: xyz
    z := make([]byte, len(x))
    // To copy the value to another slice, but 
    // but not the memory address use copy:
    _ = copy(z, x)            // returns count of items copied
    fmt.Printf("%s", z)       // prints: xyz
    z[0], z[1], z[2] = 'a', 'b', 'c'
    fmt.Printf("%s", x)       // prints: xyz
    fmt.Printf("%s", z)       // prints: abc
}

Puntatori semplici

func swap(x, y *int) {
  *x, *y = *y, *x
}

func main() {
  x := int(1)
  y := int(2)
  // variable addresses
  swap(&x, &y)
  fmt.Println(x, y)
}