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
}

このコードを試してください

ポインタと値のメソッド

ポインタメソッド

ポインタメソッドは、変数自体がポインタでなくても呼び出すことができます。

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

それを再生する

値のメソッド

ポインタメソッドと同様に、変数自体が値でなくても、valueメソッドを呼び出すことができます。

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。値についてのEffective Goのセクションを参照してください。

注1： .Barようなセレクタの前の*pと&f前後のかっこ（ () ）は、グループ化の目的で存在し、保持する必要があります。

注2：メソッドのレシーバである場合、ポインタは値に変換できます（またその逆もあります） 。関数の内部で引数を指定すると、ポインタは自動的に相互に変換されません。

ポインタを間接参照する

ポインタは、ポインタの前にアスタリスク*を追加することによって逆参照することができます。

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