In-depth analysis of Golang slicing: underlying data structure and implementation

Golang slicing principle analysis: underlying data structure and implementation

Introduction:

In Golang, slicing (Slice) is a very commonly used method data structure. It provides a convenient way to operate on contiguous sequences of elements. The design and implementation behind slicing hides many details. In the process of using slicing, understanding its underlying data structure and implementation will help to better understand its behavior and performance characteristics.

1. The definition and basic concepts of slices

A slice is composed of a pointer to the underlying array, length and capacity. It can be created using the make() function, or obtained by intercepting an existing array or slice.

The length of a slice represents its actual number of elements, while the capacity represents the maximum number of elements that can be accommodated. Slices are dynamic and can be expanded as needed.

2. The underlying data structure of the slice

The underlying data structure of the slice consists of three parts, which are the pointer to the underlying array, length and capacity. Among them, the pointer to the underlying array is used to locate the starting position of the slice, the length represents the number of elements actually stored in the slice, and the capacity represents the maximum number of elements that the slice can accommodate.

The sample code is as follows:

package main

import "fmt"

func main() {
    // 创建一个切片
    s := make([]int, 5, 10)

    // 输出切片的长度、容量和底层数组指针
    fmt.Println("Length:", len(s))
    fmt.Println("Capacity:", cap(s))
    fmt.Println("Pointer to underlying array:", &s[0])
}

Running result:

Length: 5
Capacity: 10
Pointer to underlying array: 0x10caf1010

As you can see, the length, capacity and underlying array pointer of the slice are output.

3. Slicing expansion mechanism

In the process of using slicing, when the number of elements in the slice exceeds the capacity, the slice will be expanded. The slice expansion strategy in Golang is to expand by 2 times.

The process of slice expansion involves memory reallocation and copying of elements. Therefore, frequent use of the append() function to add elements to the slice may cause performance degradation. In actual development, if the maximum capacity of the slice can be estimated, it is best to specify it when creating the slice.

The sample code is as follows:

package main

import "fmt"

func main() {
    // 创建切片
    s := make([]int, 5, 10)

    // 输出切片的长度、容量和底层数组指针
    fmt.Println("Length:", len(s))
    fmt.Println("Capacity:", cap(s))
    fmt.Println("Pointer to underlying array:", &s[0])

    // 向切片中添加元素
    for i := 0; i < 6; i++ {
        s = append(s, i)

        // 输出切片的长度、容量和底层数组指针
        fmt.Println("Length:", len(s))
        fmt.Println("Capacity:", cap(s))
        fmt.Println("Pointer to underlying array:", &s[0])
    }
}

Running result:

Length: 5
Capacity: 10
Pointer to underlying array: 0x10caf1010
Length: 6
Capacity: 10
Pointer to underlying array: 0x10caf1010

It can be seen that in the process of adding elements to the slice, the capacity of the slice will be dynamically expanded, but the underlying data structure (underlying array pointer) does not change.

4. Slice interception and sharing of underlying arrays

Slices can be obtained by intercepting other slices or arrays. The truncated slice shares the underlying array with the original slice, but has its own length and capacity.

The sample code is as follows:

package main

import "fmt"

func main() {
    // 创建一个切片
    s1 := []int{1, 2, 3, 4, 5}

    // 截取切片
    s2 := s1[1:3]

    // 输出截取切片的长度、容量和底层数组指针
    fmt.Println("Length:", len(s2))
    fmt.Println("Capacity:", cap(s2))
    fmt.Println("Pointer to underlying array:", &s2[0])
}

Running result:

Length: 2
Capacity: 4
Pointer to underlying array: 0x10caf1038

In the above example, we obtained s2 by intercepting slice s1. As you can see, the length of s2 is 2, the capacity is 4, and it shares the underlying array, but the starting position is index 1.

Summary:

Through the above analysis, we can understand the underlying data structure and implementation of Golang slicing. As an important data structure, slicing is widely used in Golang. Understanding its underlying principles and related features will help you better understand and use slicing, and enable you to use slicing more efficiently in development.

References:

• https://tour.golang.org/
• https://go.dev/

The above is the detailed content of In-depth analysis of Golang slicing: underlying data structure and implementation. For more information, please follow other related articles on the PHP Chinese website!