Go
указатели

Синтаксис

• pointer: = & variable // получить указатель от переменной
• variable: = * pointer // получить переменную из указателя
• * pointer = value // установить значение из переменной через указатель
• pointer: = new (Struct) // получить указатель новой структуры

Основные указатели

Go поддерживает указатели , позволяя вам передавать ссылки на значения и записи в вашей программе.

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
}

Как только эти функции определены, вы можете сделать следующее:

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
}

Попробуйте этот код

Метод указателя v.

Методы указателей

Методы указателей можно вызвать, даже если сама переменная не является указателем.

Согласно Go Spec ,

, , , ссылка на метод без интерфейса с приемником указателя с использованием адресного значения автоматически примет адрес этого значения: t.Mp эквивалентен (&t).Mp .

Вы можете увидеть это в этом примере:

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

Сыграй

Методы оценки

Подобно методам указателей, методы значений можно вызывать, даже если сама переменная не является значением.

Согласно Go Spec ,

, , , ссылка на метод без интерфейса с приемником значений с использованием указателя автоматически разыгрывает этот указатель: pt.Mv эквивалентно (*pt).Mv .

Вы можете увидеть это в этом примере:

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

Сыграй

Чтобы узнать больше о методах указателя и значения, перейдите в раздел Go Spec по значениям метода или просмотрите раздел « Эффективный ход» о указателях v. Значения .

Примечание 1: Скобки ( () ) вокруг *p и &f перед селекторами типа .Bar существуют для целей группировки и должны быть сохранены.

Примечание 2: Хотя указатели могут быть преобразованы в значения (и наоборот), когда они являются приемниками для метода, они не преобразуются автоматически в eachother, когда они являются аргументами внутри функции.

Указатели разыменования

Указатели могут быть разыменованы добавлением звездочки * перед указателем.

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
}

Срезки - это точки указателей на массивы

Срезы - это указатели на массивы, длина сегмента и его емкость. Они ведут себя как указатели и присваивают их значение другому фрагменту, назначают адрес памяти. Чтобы скопировать значение среза в другое, используйте встроенную функцию копирования : func copy(dst, src []Type) int (возвращает количество копируемых элементов).

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
}

Простые указатели

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