Comment comprendre les tranches dans les structures Golang

Dans Golang, une structure est un type de données personnalisé qui peut contenir plusieurs champs. Dans une structure, une tranche est un tableau dynamique qui peut être étendu ou réduit selon les besoins. Cependant, comprendre les tranches dans les structures Golang peut prêter à confusion. Dans cet article, l'éditeur PHP Youzi vous expliquera en détail le principe de fonctionnement et l'utilisation des tranches dans la structure Golang, vous aidant ainsi à mieux comprendre et appliquer cette fonctionnalité. Que vous soyez débutant ou développeur expérimenté, cet article vous apportera de précieuses connaissances et conseils pratiques pour vous rendre plus à l'aise dans le développement Golang.

Contenu de la question

Je suis nouveau sur Golang et j'essaie de comprendre les pointeurs

type deque struct {
    indexes []int
}

func (d *deque) push(i int) {
    d.indexes = append(d.indexes, i)
}

L'index ici est une tranche plutôt qu'un pointeur vers une tranche.

Comment les index sont-ils réellement stockés en mémoire ?

Par exemple : lorsque nous démarrons une instance deque, nous l'appelons dq, et en mémoire, l'adresse de dq est 0x1001 (nous l'appelons adr(dq)).

Quelles sont les variables stockées dans adr(dq) ? Est-ce un pointeur vers un tableau ?

0x1001 -> Ox8009 (l'adresse du premier élément du tableau)

Ou le tableau lui-même ?

0x1001 -> Le premier élément de la tranche

0x1002 -> Le deuxième élément de la tranche

Que se passe-t-il lorsque nous :

d.indexes = append(d.indexes, i)

Quelle est la différence si on définit :

type deque struct {
    indexes *[]int
}

Solution

Par exemple, l'adresse de l'instance deque en mémoire est 0x1001. Il initialise :

0x1001 -> [indexes: nil]

Si vous ajoutez un nouvel élément (dq.push(12)) :

0x1001 -> [length: 1, capacity: 1, data: 0x3001 (pointer to data)]
0x3001 -> [12]

La structure de tranche en

0x1001 contient des informations sur la longueur et la capacité de la tranche (longueur : 1, capacité : 1), les données réelles sont stockées à une autre adresse (disons 0x3001, tableau[12]).

Si vous poussez d'autres éléments (dq.push(34)、dq.push(56)).

0x1001 -> [length: 3, capacity: 4, data: 0x5001 (new pointer to data due to capacity, capacity doubles)]
0x5001 -> [12, 34, 56]

Code 1 :

type deque struct {
    indexes []int
}
func (d *deque) push(i int) {
    d.indexes = append(d.indexes, i)
}
func main() {
    dq := deque{}
    dq.push(12)
    dq.push(34)
    dq.push(56)
    fmt.Println("Deque elements:", dq.indexes)
}

Sortie 1 :

Deque elements: [12 34 56]

Si vous utilisez des pointeurs vers des tranches (*[]int) 而不是切片本身 ([]int). Cela signifie que le champ index contiendra un pointeur vers la tranche et que ce pointeur doit être initialisé avant de l'utiliser.

Si vous ajoutez un nouvel élément (dq.push(12)），则0x2001就是indexes), alors

est l'adresse de la structure de tranche sous-jacente pointée par index

0x1001 -> [indexes: 0x2001 (pointer to slice)]
0x2001 -> [length: 1, capacity: 1, data: 0x3001 (pointer to data)]
0x3001 -> [12]

La structure de tranche en 0x2001

contient les informations de longueur et de capacité de la tranche (longueur : 1, capacité : 1), et les données réelles sont stockées à une autre adresse (0x3001, tableau[12]).

dq.push(34)、dq.push(56)Si vous poussez d'autres éléments (

).

0x1001 -> [indexes: 0x2001 (pointer to slice)]
0x2001 -> [length: 3, capacity: 4, data: 0x5001 (new data pointer, due to capacity, capacity doubles)]
0x5001 -> [12, 34, 56]

Code 2 :

type deque struct {
    indexes *[]int
}

func (d *deque) push(i int) {
    if d.indexes == nil {    // initialize the slice if it's nil
        d.indexes = &[]int{}
    }
    *d.indexes = append(*d.indexes, i)
}

func main() {
    dq := deque{}
    dq.push(12)
    dq.push(34)
    dq.push(56)
    fmt.Println("Deque elements:", *dq.indexes)
}

Sortie 2 : 🎜

Deque elements: [12 34 56]

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!