当前位置： > > > > 为什么指针赋值会导致变量赋值不总是粘住？

为什么指针赋值会导致变量赋值不总是粘住？

来源：stackoverflow
2024-04-26 09:54:34
0浏览
收藏

来到米云的大家，相信都是编程学习爱好者，希望在这里学习Golang相关编程知识。下面本篇文章就来带大家聊聊《为什么指针赋值会导致变量赋值不总是粘住？》，介绍一下，希望对大家的知识积累有所帮助，助力实战开发！

问题内容

索引的指针分配在 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
}

我希望 p.two.y: [#'s] 的#’s 始终等于 p.one.y: [#'s] 的以下行。我得到的输出并不总是相等。有时，p.one.y: [#'s] #’s 等于上一行中的 p.two.y: [#'s]；该值被覆盖，然后该值又回来了。

p.one.y:  [0.20700021 0.30003001]
p.two.y:  [0.04284908694004409 0.0900180069006001]/////// bad
p.two.y:  [0.5107106330188076 0.5224893174114301]      // overwritten
p.one.y:  [0.04284908694004409 0.0900180069006001]/////// reappeared
p.two.y:  [0.0018360442515954571 0.008103241566356488]
p.two.y:  [0.5004590109339528 0.5020257993066767]//// overwritten
p.one.y:  [0.5004590109339528 0.5020257993066767]//// good
p.two.y:  [0.25045922162499035 0.25202990316950763]
p.two.y:  [0.5622895277500193 0.5626760660176802]

我尝试减少函数嵌套，当我将所有内容放入 propagate() 函数并使用 sigmoid 函数直接分配给 p.two.y[i] 时，它起作用了。 （下）

// propagate 
func (l *lots)propagate(){
    for _, p := range l.join{
        fmt.println("p.one.y: ", p.one.y)
        
        for i := range p.one.y {
            p.two.y[i] = p.one.y[i] * p.one.y[i]
        }
        fmt.println("p.two.y: ", p.two.y)
        
        // using this extra variable causes the problem of inconsistent assignment
        //y := make([]float64, len(p.two.y))
        for i := range p.two.y{
            //y[i] = 1./(1.+math.exp(-p.two.y[i]))
            p.two.y[i] = 1./(1.+math.exp(-p.two.y[i]))
        }
        //p.two.y = y
        
        fmt.println("p.two.y: ", p.two.y)
    }
}

这个版本提供了很好的数据，但剥夺了我喜欢的很多专业知识。

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

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

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持米云！更多关于Golang的相关知识，也可关注米云公众号。