Início / coding / Perguntas / 76938226
Accepted
Mandroid
Asked: 2023-08-20 14:42:44 +0800 CST

golang: compartilhamento de matriz entre fatias

  • 772

Isso explica a função de acréscimo para fatias.

Como diz, append retorna a fatia atualizada.

Então, isso significa que a fatia recém-criada não compartilha a matriz subjacente com a fatia existente?

No caso de outras operações de fatia, como mySlice[x:y], a nova fatia compartilharia a matriz subjacente com mySlice, como mostrado .

PS: Código de teste:

var names = make([]string, 4, 10)
names1 := append(names, "Tom")

Portanto, neste caso, há capacidade suficiente disponível em nomes. Portanto, o acréscimo não deve criar uma nova matriz subjacente.

Isso gera:

[   ]
[    Tom]

A saída não deveria ser a mesma que a matriz subjacente é compartilhada?

Certamente estou perdendo algo muito básico aqui.

go

2 respostas

  1. Append retorna uma nova estrutura de fatia, mas a matriz subjacente pode ser compartilhada ou não, dependendo da capacidade: se a capacidade for suficiente, ela será compartilhada, caso contrário, não.

    Slice struct tem comprimento, capacidade e ponteiro para campos de matriz subjacentes:

    type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

    Aqui estão alguns exemplos:

    package main

import "fmt"

func foo(a []int) {
    // new array allocated, returned new slice struct
    // and it is assigned to local copy of slice struct
    a = append(a, 7)

    // element changed in local copy of slice struct
    a[1] = 7
}

func bar(a *[]int) {
    // new array allocated, returned new slice struct
    // and it is assigned to the variable declared on first line of main function
    // as it is passed by reference
    *a = append(*a, 7)
}

func main() {
    // new slice, len and capacity equals number of elements
    a := []int{1, 2, 3, 4, 5, 6}
    fmt.Printf("a[1]=%d\n", a[1])

    // array shared, will print a[1]=10
    b := a[1:3]
    b[0] = 10
    fmt.Printf("1. a[1]=%d\n", a[1])

    // new array allocated, will print a[1]=10
    b = append(b, a...)
    b[0] = 100
    fmt.Printf("2. a[1]=%d\n", a[1])

    // new array allocated, will print a[1]=10
    foo(a)
    fmt.Printf("3. a[1]=%d\n", a[1])

    // will print [1 10 3 4 5 6 7]
    bar(&a)
    fmt.Printf("4. a=%v\n", a)
}
    • 0
  2. Best Answer

    Você está certo, names1usa a mesma matriz subjacente que names.

    E não, a saída não deve ser a mesma, pois namestem comprimento 4, enquanto names1tem comprimento 5. Observe que ambos possuem capacidade (10).

    Aqui está um exemplo, que pode esclarecer um pouco:

    func main() {
    emptyNames := make([]string, 0, 10)
    notEmptyNames := append(emptyNames, "Jerry")
    extendedNames := emptyNames[:1] // OK, because 1 < cap(emptyNames)
    fmt.Println("emptyNames:", emptyNames)
    //emptyNames: []
    fmt.Println("notEmptyNames:", notEmptyNames)
    //notEmptyNames: [Jerry]
    fmt.Println("extendedNames:", extendedNames)
    //extendedNames: [Jerry]
}
    • 0

relate perguntas