主页 / 问题 / 1430725
Accepted
ar rr
Asked:2022-07-18 16:56:31 +0000 UTC2022-07-18 16:56:31 +0000 UTC

Go 中的隐式引用（指针）

  • 772

我在 CodeWars 上解决简单的难题。以下代码有问题：

func FindOutlier(integers []int) int {
    coping := integers //делаем копию массива
    var DosZeroCount int = 0
    var DosZeroNotCount int = 0
    for index, _ := range coping {
        coping[index] = coping[index] % 2
        if coping[index] == 1 {
            DosZeroNotCount++
        } else {
            DosZeroCount++
        }
    }//обнуляется integers без одного элемента

问题是应对是对原始数组的隐式引用。根据语言描述，这样的动作coping := integers应该完全复制数组，而不是创建指向它的链接。如何复制整个数组？我怀疑重点是整数是一个函数参数......

golang

1 个回答

  1. Best Answer

    使用数组和映射是不同的，您需要了解一些规则。

    coping := integers当您更改元素的状态但不希望它在地图或数组中更改时，可以在范围内工作。

        m := map[string]int{"a": 1, "b": 2, "c": 3}
    for k, v := range m {
        copyOfValue := v
        copyOfValue = 10
        v = 11
        fmt.Printf("copyOfValue: %s: %d\n", k, copyOfValue)
        break
    }

    fmt.Printf("m: %v\n", m)


    copyOfValue: c: 10
m: map[a:1 b:2 c:3]

    for i := range a并且for i, v := range &a永远不要创建副本a，但在这里它for i, v := range a会创建一个副本））您只需要记住。在这里自己看看

    func IndexArray() {
    a := [...]int{1, 2, 3, 4, 5, 6, 7, 8}

    for i := range a {
        a[3] = 100
        if i == 3 {
            fmt.Println("IndexArray", i, a[i])
        }
    }
}

func IndexValueArray() {
    a := [...]int{1, 2, 3, 4, 5, 6, 7, 8}

    for i, v := range a {
        a[3] = 100
        if i == 3 {
            fmt.Println("IndexValueArray", i, v)
        }
    }
}

func IndexValueArrayPtr() {
    a := [...]int{1, 2, 3, 4, 5, 6, 7, 8}

    for i, v := range &a {
        a[3] = 100
        if i == 3 {
            fmt.Println("IndexValueArrayPtr", i, v)
        }
    }
}

func main() {
    IndexArray()
    IndexValueArray()
    IndexValueArrayPtr()
}


    IndexArray 3 100
IndexValueArray 3 4
IndexValueArrayPtr 3 100

    播放链接

    因此，制作数组副本的最简单方法是

        src := []int{1, 2, 3, 4, 5}
    dst := make([]int, len(src))
    numberOfElementsCopied := copy(dst, src)

    现在谈谈切片（切片）

    Golang 有切片的概念——它几乎就像一个数组，只是它的行为不像一个数组。例如下面的代码将复制

    arr1:=[...]int{1,2,3}
arr2:=arr1
arr1[1]=99
fmt.Println(arr1)
fmt.Println(arr2)

[1 99 3]
[1 2 3]

    但是如果“复制”这样改变，那么原来的数组也会改变

    arr1:=[...]int{1,2,3}
arr2:=arr1[:]
arr1[1]=99
fmt.Println(arr1)
fmt.Println(arr2)

[1 99 3]
[1 99 3]

    这一切都是因为切片是指向数组的指针（更准确地说，新切片的每个元素都引用原始切片的一个元素）。

    切片不会复制切片的数据。它创建一个指向原始数组的新切片值。这使得切片操作与操作数组索引一样高效。因此，修改重新切片的元素（而不是切片本身）会修改原始切片的元素

    这里是源

    总计，以免混淆

    array := [5]int{1, 2, 3, 4, 5} // это массив
slice := array[:]              // это срез массива
slice := [...]int{1, 2, 3, 4, 5} // это срез массива
slice := int{1, 2, 3, 4, 5} // это срез массива
    • 1

相关问题