Go 为什么指针赋值会导致变量赋值不总是保持不变？

索引的指针分配在

addData（..）

中始终不一致。我预计内存地址会随着底层阵列大小的增加而移动

行为：我分配给变量

A

，然后分配

B=A*0.2

，然后分配

y=sig（B）

，最后分配

B=y

。有时在下一个循环中

B==y

| |

B==A*0.2

。它在多次执行中是完全一致的

我制作了一个更简单、更完整的代码版本

package main

import(
    "fmt"
    "math"
)

func main(){
    //Structure setup
    l := lots{}; l.addData(2); l.addData(2); l.addData(2); l.addData(2)
    
    l.val[0].y[0] = 0.20700021
    l.val[0].y[1] = 0.30003001
    l.propagate()
}

type data struct{
    y []float64
}

type pair struct {
    one *data
    two *data
}

// lots is the biggest part of the structure
// the problem seems to occure when this is introduced
type lots struct{
    val []data
    join []pair
}

// addData appends a data struct and a pair struct to
// the corresponding parts of lots struct
func (l *lots)addData(size int){
    l.val = append(l.val, data{make([]float64, size)})
    
    // should be skipped first call only
    if(len(l.join) < len(l.val)-1){
        fmt.Println("len of l.val: ", len(l.val)) 
        l.join = append(l.join, pair{})
        l.join[len(l.join)-1].one = &l.val[len(l.val)-2]
        l.join[len(l.join)-1].two = &l.val[len(l.val)-1]
    }
}

// propagate 
func (l *lots)propagate(){
    for _, v := range l.join{
        v.travel()
    }
}

// travel modifies values going from p.one -> p.two
func (p *pair) travel(){
    fmt.Println("p.one.y: ", p.one.y)
    p.mathy()
    fmt.Println("p.two.y: ", p.two.y)
    
    p.two.y = sigmoid(p.two.y)
    fmt.Println("p.two.y: ", p.two.y)
}

func (p *pair) mathy(){
    for i := range p.one.y {
        p.two.y[i] = p.one.y[i] * p.one.y[i]
    }
}

// sigmoid seems to be causing some problems.
// Works fine on it's own though
func sigmoid(x []float64)(y []float64){
    y = make([]float64, len(x))
    for i := range x{
        y[i] = 1./(1.+math.Exp(-x[i]))
    }
    return
}

我曾尝试减少函数嵌套，当我将所有内容放入

Propagate（）

函数并使用sigmoid函数直接分配给

p.two.y[I]

时，它就起到了作用。（下文）

这个版本提供了很好的数据，但却剥夺了我喜欢的专业化

p.one.y:  [0.20700021 0.30003001]
p.two.y:  [0.04284908694004409 0.0900180069006001]
p.two.y:  [0.5107106330188076 0.5224893174114301]////
p.one.y:  [0.5107106330188076 0.5224893174114301]//// Good
p.two.y:  [0.2608253506784712 0.27299508680906215]
p.two.y:  [0.564839170446528 0.5678280461350629]////
p.one.y:  [0.564839170446528 0.5678280461350629]//// Good
p.two.y:  [0.3190432884707219 0.3224286899775631]
p.two.y:  [0.5790910765397528 0.5799160282084651]

---

问题在于在构建试图引用的切片时指针赋值。地址不断变化

func main(){
    var lump []int
    
    // A loop to build a slice of `int`'s from 0 size to 8 size
    // and print each index address
    for i:= 0; i < 8; i++{
        lump = append(lump, int(i))
        fmt.Printf("addr of lump[%v]: %p\n",i, &lump[i])
    }
    
    fmt.Println()
    
    // A loop to look at the addresses of each index
    for i := range lump{
        fmt.Printf("addr of lump[%v]: %p\n",i, &lump[i])
    }
}

---

您可以转移到C/C++中，在那里，随着阵列大小的增加，您可以处理所有内存调整。或者先构建一个片段，然后再构建另一个片段。

请参见Hi@Volker，谢谢您的链接，但除了主goroutine之外，我没有使用goroutine。它从技术上回答了我的问题“如何”，但对我来说，指针变量有时像指针一样作用，更新对象，有时像局部变量一样不更新对象。问题是循环变量的使用。这个问题体现在以goroutines（FAQ）或您的代码形式运行的闭包中。@Volker我找到的闭包和goroutines的唯一一点是用于在循环中使用

go funcName（）

时。是否有一些更模糊的东西不涉及go关键字？您必须理解，

for i，v:=…

只使用一个变量

v

，该变量在每次循环迭代时更新其值。这与goroutines无关。

p.one.y:  [0.20700021 0.30003001]
p.two.y:  [0.04284908694004409 0.0900180069006001]
p.two.y:  [0.5107106330188076 0.5224893174114301]////
p.one.y:  [0.5107106330188076 0.5224893174114301]//// Good
p.two.y:  [0.2608253506784712 0.27299508680906215]
p.two.y:  [0.564839170446528 0.5678280461350629]////
p.one.y:  [0.564839170446528 0.5678280461350629]//// Good
p.two.y:  [0.3190432884707219 0.3224286899775631]
p.two.y:  [0.5790910765397528 0.5799160282084651]

func main(){
    var lump []int
    
    // A loop to build a slice of `int`'s from 0 size to 8 size
    // and print each index address
    for i:= 0; i < 8; i++{
        lump = append(lump, int(i))
        fmt.Printf("addr of lump[%v]: %p\n",i, &lump[i])
    }
    
    fmt.Println()
    
    // A loop to look at the addresses of each index
    for i := range lump{
        fmt.Printf("addr of lump[%v]: %p\n",i, &lump[i])
    }
}

//while building the slice
// notice the addresses making big jumps
addr of lump[0]: 0xc00000a0c8
addr of lump[1]: 0xc00000a0f8
addr of lump[2]: 0xc00000e3b0
addr of lump[3]: 0xc00000e3b8
addr of lump[4]: 0xc00000c2e0
addr of lump[5]: 0xc00000c2e8
addr of lump[6]: 0xc00000c2f0
addr of lump[7]: 0xc00000c2f8

//after building the slice
// notice all address being sequential
addr of lump[0]: 0xc00000c2c0
addr of lump[1]: 0xc00000c2c8
addr of lump[2]: 0xc00000c2d0
addr of lump[3]: 0xc00000c2d8
addr of lump[4]: 0xc00000c2e0
addr of lump[5]: 0xc00000c2e8
addr of lump[6]: 0xc00000c2f0
addr of lump[7]: 0xc00000c2f8