Pointers 声明指向结构的指针

我很困惑，因为在go语言中，似乎有两种方法可以初始化指向结构的指针，而它们在逻辑上似乎有些相反

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

为什么一个使用a*而另一个使用a&如果b和c具有相同的结果类型？我很抱歉没有充分理解与此主题相关的帖子

在这方面，“接收者”的含义我也还不清楚。我熟悉的术语是“引用（a）”或“指向（a）”或“地址（a）”和“撤销引用”或“地址处的值”

---

提前感谢您的帮助。

var c=&Vertex{3，3}

（您确实需要

=

）正在声明一个结构，然后获取对它的引用（它实际分配结构，然后获取对该内存的引用（指针））

var b*Vertex

将b声明为指向顶点的指针，但根本不初始化它。您将有一个零指针

但是是的，类型是一样的

您还可以执行以下操作：

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

---

var c=&Vertex{3，3}

（您确实需要

=

）声明一个结构，然后获取对它的引用（它实际分配结构，然后获取对该内存的引用（指针））

var b*Vertex

将b声明为指向顶点的指针，但根本不初始化它。您将有一个零指针

但是是的，类型是一样的

您还可以执行以下操作：

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

---

var c=&Vertex{3，3}

（您确实需要

=

）声明一个结构，然后获取对它的引用（它实际分配结构，然后获取对该内存的引用（指针））

var b*Vertex

将b声明为指向顶点的指针，但根本不初始化它。您将有一个零指针

但是是的，类型是一样的

您还可以执行以下操作：

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

---

var c=&Vertex{3，3}

（您确实需要

=

）声明一个结构，然后获取对它的引用（它实际分配结构，然后获取对该内存的引用（指针））

var b*Vertex

将b声明为指向顶点的指针，但根本不初始化它。您将有一个零指针

但是是的，类型是一样的

您还可以执行以下操作：

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

---

除了韦斯·弗里曼提到的以外，你还询问了接受者的情况

假设你有：

type Vertex struct {
} 

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

顶点结构是func Hello（）的接收器。因此，您可以执行以下操作：

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

---

除了韦斯·弗里曼提到的以外，你还询问了接受者的情况

假设你有：

type Vertex struct {
} 

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

顶点结构是func Hello（）的接收器。因此，您可以执行以下操作：

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

---

除了韦斯·弗里曼提到的以外，你还询问了接受者的情况

假设你有：

type Vertex struct {
} 

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

顶点结构是func Hello（）的接收器。因此，您可以执行以下操作：

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

---

除了韦斯·弗里曼提到的以外，你还询问了接受者的情况

假设你有：

type Vertex struct {
} 

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

顶点结构是func Hello（）的接收器。因此，您可以执行以下操作：

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

---

有多种方法可以声明指向

struct

的指针，并为

struct

字段赋值。比如说,

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

输出：

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

&{4 2}
&{42 24}

参考资料：

接收器用于方法。例如，v是顶点移动方法的接收器

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

输出：

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

&{4 2}
&{42 24}

参考资料：

---

有多种方法可以声明指向

结构的指针，并为
结构
字段赋值。比如说,

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

输出：

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

&{4 2}
&{42 24}

参考资料：







接收器用于方法。例如，v是顶点移动方法的接收器

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

输出：

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

&{4 2}
&{42 24}

参考资料：






有多种方法可以声明指向
结构的指针，并为
结构
字段赋值。比如说,

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

输出：

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

&{4 2}
&{42 24}

参考资料：







接收器用于方法。例如，v是顶点移动方法的接收器

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

输出：

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

&{4 2}
&{42 24}

参考资料：






有多种方法可以声明指向
结构的指针，并为
结构
字段赋值。比如说,

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

输出：

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

&{4 2}
&{42 24}

参考资料：







接收器用于方法。例如，v是顶点移动方法的接收器

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

输出：

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

&{4 2}
&{42 24}

参考资料：






接收器不必是
struct
s。例如，如果我们有
类型Integer int
，那么我们可以有
类型Integer
或
*Integer
@peters的接收器，谢谢你指出这一点。我修改了我的语句。接收者不必是
struct
s。例如，如果我们有
类型Integer int
，那么我们可以有
类型Integer
或
*Integer
@peters的接收器，谢谢你指出这一点。我修改了我的语句。接收者不必是
struct
s。例如，如果我们有
类型Integer int
，那么我们可以有
类型Integer
或
*Integer
@peters的接收器，谢谢你指出这一点。我修改了我的语句。接收者不必是
struct
s。例如，如果我们有
类型Integer int
，那么我们可以有
类型Integer
或
*Integer
@peters的接收器，谢谢你指出这一点。我修改了我的声明，谢谢各位。我收集的是，类型上的*运算符不是我假设的反引用运算符，而是更像指向nil实例的指针运算符，而&是指向初始化实例的指针运算符。是这样吗？*德里夫这样做吗