在 Go 中创建多维数组：数组的数组 vs. 切片的切片-Golang-PHP中文网

在 Go 中创建多维数组：数组的数组 vs. 切片的切片

花韻仙語

发布： 2025-10-08 10:33:21

原创

588人浏览过

在 go 中创建多维数组：数组的数组 vs. 切片的切片

本文将深入探讨在 Go 语言中创建多维数组的两种主要方法：数组的数组和切片的切片。我们将详细比较这两种方法的内部机制、内存使用情况、灵活性以及作为函数参数时的行为差异，并通过代码示例展示它们的特性和适用场景，帮助开发者根据实际需求做出最佳选择。

数组的数组

在 Go 语言中，我们可以创建一个数组，其元素本身也是数组，从而形成“数组的数组”，也称为多维数组。这种方式在内存中是连续存储的，因此访问效率较高，尤其是在处理固定大小的矩阵或表格数据时。

package main

import "fmt"

func main() {
    // 创建一个 2x2 的整型数组的数组
    a := [2][2]int{{0, 1}, {2, 3}}

    // 遍历并打印数组元素及其内存地址
    fmt.Println("Array of Arrays")
    for i := 0; i < 2; i++ {
        for j := 0; j < 2; j++ {
            fmt.Printf("a[%d][%d] = %d at %p\n", i, j, a[i][j], &a[i][j])
        }
    }
}

登录后复制

这段代码创建了一个 [2][2]int 类型的数组 a，并使用嵌套循环遍历了它的所有元素，同时打印了每个元素的数值及其在内存中的地址。由于是数组的数组，所以内存是连续分配的。

切片的切片

另一种创建多维结构的方法是使用“切片的切片”。切片是 Go 语言中一种动态数组，它比数组更加灵活。切片的切片允许每一行（或子切片）拥有不同的长度，因此非常适合处理不规则的数据结构。

package main

import "fmt"

func main() {
    // 创建一个 2x2 的整型切片的切片
    b := [][]int{{0, 1}, {2, 3}}

    // 遍历并打印切片元素及其内存地址
    fmt.Println("Slice of Slices")
    for i := 0; i < 2; i++ {
        for j := 0; j < 2; j++ {
            fmt.Printf("b[%d][%d] = %d at %p\n", i, j, b[i][j], &b[i][j])
        }
    }
}

登录后复制

这段代码创建了一个 [][]int 类型的切片 b，并同样遍历并打印了元素值和地址。与数组的数组不同，切片的切片中的每个子切片可能在内存中位于不同的位置。

内存使用比较

由于数组的数组在内存中是连续存储的，因此其内存占用通常比切片的切片更小。切片的切片需要额外的空间来存储每个子切片的头部信息，并且子切片的数据可能分散在内存的不同位置。

以下是一个简单的对比示例，展示了创建大量数组的数组和切片的切片时的内存使用差异：

AssemblyAI

转录和理解语音的AI模型

查看详情

package main

import "fmt"
import "runtime"

func main() {
    // Array of Arrays
    var m runtime.MemStats
    runtime.GC()
    runtime.ReadMemStats(&m)
    alloc1 := m.Alloc

    a := [100000][3]int{}
    _ = a

    runtime.GC()
    runtime.ReadMemStats(&m)
    alloc2 := m.Alloc

    fmt.Printf("Array of Arrays uses %d bytes\n", alloc2-alloc1)

    // Slice of Slices
    runtime.GC()
    runtime.ReadMemStats(&m)
    alloc1 = m.Alloc

    b := make([][]int, 100000)
    for i := range b {
        b[i] = make([]int, 3)
    }
    _ = b

    runtime.GC()
    runtime.ReadMemStats(&m)
    alloc2 = m.Alloc

    fmt.Printf("Slice of Slices uses %d bytes\n", alloc2-alloc1)
}

登录后复制

在运行这段代码后，你会发现切片的切片占用的内存明显多于数组的数组。

作为函数参数的差异

数组和切片在作为函数参数时，表现出不同的行为。数组是值类型，当数组作为参数传递给函数时，会创建一个数组的副本。这意味着在函数内部对数组的修改不会影响原始数组。切片是引用类型，当切片作为参数传递给函数时，传递的是切片的引用（或者说是切片头部的拷贝，但底层数组是共享的）。因此，在函数内部对切片的修改会影响原始切片。

package main

import "fmt"

func f1(a [2][2]int) {
    fmt.Println("I'm a function modifying an array of arrays argument")
    a[0][0] = 100
}

func f2(b [][]int) {
    fmt.Println("I'm a function modifying an slice of slices argument")
    b[0][0] = 100
}

func main() {
    fmt.Println("Array of arrays")
    a := [2][2]int{{0, 1}, {2, 3}}
    fmt.Printf("Before %v\n", a)
    f1(a)
    fmt.Printf("After %v\n\n", a)

    fmt.Println("Slice of slices")
    b := [][]int{{0, 1}, {2, 3}}
    fmt.Printf("Before %v\n", b)
    f2(b)
    fmt.Printf("After %v\n", b)
}

登录后复制

运行结果：

Array of arrays
Before [[0 1] [2 3]]
I'm a function modifying an array of arrays argument
After [[0 1] [2 3]]

Slice of slices
Before [[0 1] [2 3]]
I'm a function modifying an slice of slices argument
After [[100 1] [2 3]]

登录后复制

可以看到，f1 函数修改了数组的副本，原始数组 a 保持不变。而 f2 函数修改了切片的底层数组，因此原始切片 b 也被修改了。