CODEWITHSUNDEEP
pointersgo
user3143255
user3143255

Reputation:

Declaring a pointer to a struct

I'm confused because there seem to be two ways to initialize a pointer to a struct in the go language and they appear to me to be somewhat opposite in logic.

var b *Vertex
var c &Vertex{3 3}

Why does one use a * and the other use a & if b and c have the same resulting type? My apologies for not adequately understanding the posts already up related to this topic.

I am also not yet straight on the implications of "receivers" in this context. The terminology I am familiar with is "reference to (a)" or "pointer to (a)" or "address of (a)" and "de-reference of" or "value at address".

Thanks in advance for your help.

Upvotes: 0

Views: 358

Answers (3)

rexposadas
rexposadas

Reputation: 3189

In addition to what Wes Freeman mentioned, you also asked about receivers.

Let say you have this:

type Vertex struct {
} 

func (v *Vertex) Hello() {
   ... do something ...
}

The Vertex struct is the receiver for the func Hello(). So you can then do:

d := &Vertex{}
d.Hello()

Upvotes: 0

peterSO
peterSO

Reputation: 166569

There are a number of ways to declare a pointer to a struct and assign values to the struct fields. For example,

package main

import "fmt"

type Vertex struct {
    X, Y float64
}

func main() {
    {
        var pv *Vertex
        pv = new(Vertex)
        pv.X = 4
        pv.Y = 2
        fmt.Println(pv)
    }

    {
        var pv = new(Vertex)
        pv.X = 4
        pv.Y = 2
        fmt.Println(pv)
    }

    {
        pv := new(Vertex)
        pv.X = 4
        pv.Y = 2
        fmt.Println(pv)
    }

    {
        var pv = &Vertex{4, 2}
        fmt.Println(pv)
    }

    {
        pv := &Vertex{4, 2}
        fmt.Println(pv)
    }
}

Output:

&{4 2}
&{4 2}
&{4 2}
&{4 2}
&{4 2}

References:

The Go Programming Language Specification

Variable declarations

Short variable declarations

Address operators

Allocation

Composite literals

Receivers are used for methods. For example, v is the receiver for the Vertex Move Method.

package main

import "fmt"

type Vertex struct {
    X, Y float64
}

func NewVertex(x, y float64) *Vertex {
    return &Vertex{X: x, Y: y}
}

func (v *Vertex) Move(x, y float64) {
    v.X = x
    v.Y = y
}

func main() {
    v := NewVertex(4, 2)
    fmt.Println(v)
    v.Move(42, 24)
    fmt.Println(v)
}

Output:

&{4 2}
&{42 24}

References:

The Go Programming Language Specification

Method sets

Method declarations

Calls

Method expressions

Method values

Upvotes: 2

Eve Freeman
Eve Freeman

Reputation: 33145

var c = &Vertex{3, 3} (you do need the =) is declaring a struct and then getting the reference to it (it actually allocates the struct, then gets a reference (pointer) to that memory).

var b *Vertex is declaring b as a pointer to Vertex, but isn't initializing it at all. You'll have a nil pointer.

But yes, the types are the same.

You can also do:

var d *Vertex
d = &Vertex{3,3}

Upvotes: 1

Related Questions