本文将深入探讨在 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，并同样遍历并打印了元素值和地址。与数组的数组不同，切片的切片中的每个子切片可能在内存中位于不同的位置。
内存使用比较
由于数组的数组在内存中是连续存储的，因此其内存占用通常比切片的切片更小。 切片的切片需要额外的空间来存储每个子切片的头部信息，并且子切片的数据可能分散在内存的不同位置。
以下是一个简单的对比示例，展示了创建大量数组的数组和切片的切片时的内存使用差异：
感谢使用Demila。Demila是一款由9秒社团原创的、面向数字内容及其服务的、优美的在线交易系统，她除了能为站长提供一个建站解决方案之外，还能为那些技术精湛的设计者、开发者以及资源拥有者们提供无数个拓展其作品和资源之价值的机会，从而使那些精益求精者的智慧和创意，无论是价格，还是价值，都达到应有的尺度。这是9秒社团Demila项目组的宗旨，也是Demila的使命。我们热切希望能有更多的人为Dem
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 也被修改了。
总结
- 数组的数组： 适用于固定大小的多维数据结构，内存效率高，但灵活性较差。作为函数参数时，传递的是数组的副本。
- 切片的切片： 适用于大小可变的多维数据结构，灵活性高，但内存效率较低。作为函数参数时，传递的是切片的引用，对切片的修改会影响原始切片。
在选择使用哪种方法时，需要根据具体的应用场景权衡利弊。 如果需要处理固定大小的数据，并且对性能有较高要求，那么数组的数组是更好的选择。 如果需要处理大小可变的数据，或者需要在函数内部修改多维数据结构，那么切片的切片是更合适的选择。一般来说，对于一维数据，切片通常优于数组。
