Pointers 转到循环指针更改

我在Go中使用了一个

for range

循环来迭代结构片

在每个循环中，我都将当前项的指针指向一个变量

我不明白为什么指针会在下一个循环中改变值

例如：

我希望制作：

begin <nil>
end &{1}
begin &{1}
end &{2}

开始
结束&{1}
开始&{1}
结束&{2}

但事实上：

begin <nil>
end &{1}
begin &{2}
end &{2}

开始
结束&{1}
开始&{2}
结束&{2}

作为参考，在我的实际代码中，我在循环期间检查一个条件，并返回当前项和前一项。因此，我试图保存指向它的指针，以便在下一次迭代中，它也可以访问上一次迭代。

在构建过程中，似乎可以复制每个循环上的值，而不是指针，然后取消对它的引用

package main

import "fmt"

type t struct {
    val int
}

func main() {
    l := []t{{1}, {2}}
    var p t
    var i t
    for _, i = range l {
        fmt.Println("begin", &p)
        p = i
        fmt.Println("end", &p)
    }
}

在构建之后，您似乎可以复制每个循环上的值，而不是指针，然后取消对它的引用

package main

import "fmt"

type t struct {
    val int
}

func main() {
    l := []t{{1}, {2}}
    var p t
    var i t
    for _, i = range l {
        fmt.Println("begin", &p)
        p = i
        fmt.Println("end", &p)
    }
}

在构建之后，您似乎可以复制每个循环上的值，而不是指针，然后取消对它的引用

package main

import "fmt"

type t struct {
    val int
}

func main() {
    l := []t{{1}, {2}}
    var p t
    var i t
    for _, i = range l {
        fmt.Println("begin", &p)
        p = i
        fmt.Println("end", &p)
    }
}

在构建之后，您似乎可以复制每个循环上的值，而不是指针，然后取消对它的引用

package main

import "fmt"

type t struct {
    val int
}

func main() {
    l := []t{{1}, {2}}
    var p t
    var i t
    for _, i = range l {
        fmt.Println("begin", &p)
        p = i
        fmt.Println("end", &p)
    }
}

---

另一个选项是使用索引获取指向当前项的指针：

package main

import "fmt"

type t struct {
    val int
}

func main() {
    l := []t{{1}, {2}}
    var p *t

    for index, _ := range l {
        fmt.Println("begin", p)
        p = &l[index]
        fmt.Println("end", p)
    }
}

---

另一个选项是使用索引获取指向当前项的指针：

package main

import "fmt"

type t struct {
    val int
}

func main() {
    l := []t{{1}, {2}}
    var p *t

    for index, _ := range l {
        fmt.Println("begin", p)
        p = &l[index]
        fmt.Println("end", p)
    }
}

---

另一个选项是使用索引获取指向当前项的指针：

package main

import "fmt"

type t struct {
    val int
}

func main() {
    l := []t{{1}, {2}}
    var p *t

    for index, _ := range l {
        fmt.Println("begin", p)
        p = &l[index]
        fmt.Println("end", p)
    }
}

---

另一个选项是使用索引获取指向当前项的指针：

package main

import "fmt"

type t struct {
    val int
}

func main() {
    l := []t{{1}, {2}}
    var p *t

    for index, _ := range l {
        fmt.Println("begin", p)
        p = &l[index]
        fmt.Println("end", p)
    }
}

---

问题是您获取的是循环/范围变量的地址，而不是切片中项目的地址。然而，你只是在为自己做很多不必要的工作。首先，你为什么不使用

i，v:=range

或者更好的

i，:=

然后你可以使用

i-1

来获取上一个项目？其次，即使您希望将其保存在指针中，也要使用此语法，然后分配

p=&l[i]

，这样您就得到了切片中项目的地址，而不是循环/范围变量的地址

---

当使用索引显然更好时，人们太渴望使用/each样式构造。。。如果您希望在每次迭代中都使用索引-1，那么使用索引应该是您的首选方法。

问题在于您使用的是循环/范围变量的地址，而不是切片中项目的地址。然而，你只是在为自己做很多不必要的工作。首先，你为什么不使用

i，v:=range

或者更好的

i，:=

然后你可以使用

i-1

来获取上一个项目？其次，即使您希望将其保存在指针中，也要使用此语法，然后分配

p=&l[i]

，这样您就得到了切片中项目的地址，而不是循环/范围变量的地址

---

当使用索引显然更好时，人们太渴望使用/each样式构造。。。如果您希望在每次迭代中都使用索引-1，那么使用索引应该是您的首选方法。

问题在于您使用的是循环/范围变量的地址，而不是切片中项目的地址。然而，你只是在为自己做很多不必要的工作。首先，你为什么不使用

i，v:=range

或者更好的

i，:=

然后你可以使用

i-1

来获取上一个项目？其次，即使您希望将其保存在指针中，也要使用此语法，然后分配

p=&l[i]

，这样您就得到了切片中项目的地址，而不是循环/范围变量的地址

---

当使用索引显然更好时，人们太渴望使用/each样式构造。。。如果您希望在每次迭代中都使用索引-1，那么使用索引应该是您的首选方法。

问题在于您使用的是循环/范围变量的地址，而不是切片中项目的地址。然而，你只是在为自己做很多不必要的工作。首先，你为什么不使用

i，v:=range

或者更好的

i，:=

然后你可以使用

i-1

来获取上一个项目？其次，即使您希望将其保存在指针中，也要使用此语法，然后分配

p=&l[i]

，这样您就得到了切片中项目的地址，而不是循环/范围变量的地址

---

当使用索引显然更好时，人们太渴望使用/each样式构造。。。如果您希望在每次迭代中使用索引-1，那么使用索引应该是您的首选方法。

在每次循环迭代开始时，

for

将

l

的当前元素复制到

i

中。因此它基本上在所有迭代中重用一个

i

？我认为这是有道理的。如果我在循环中，我如何保存指向实际对象的指针？在每个循环迭代开始时，

for

将

l

的当前元素复制到

I

中。因此它基本上在所有迭代中重用一个

I

？我认为这是有道理的。如果我在循环中，我如何保存指向实际对象的指针？在每个循环迭代开始时，

for

将

l

的当前元素复制到

I

中。因此它基本上在所有迭代中重用一个

I

？我认为这是有道理的。如果我在循环中，我如何保存指向实际对象的指针？在每个循环迭代开始时，

for

将

l

的当前元素复制到

I

中。因此它基本上在所有迭代中重用一个

I

？我认为这是有道理的。如果我在循环中，如何保存指向实际对象的指针？请参阅此处的常见问题解答条目：。当您不使用闭包时，

i:=i

习惯用法可能是最常见的解决方案。@JimB谢谢，这非常相关。有关常见问题解答条目，请参阅此处：。

i:=i

习语i