本文将深入探讨在 Go 语言中创建多维数组的两种主要方式：数组的数组和切片的切片。我们将详细比较这两种方法的内存使用、灵活性以及作为参数传递时的行为差异，并通过代码示例展示它们的特性和适用场景，帮助开发者选择最适合其需求的数据结构。
数组的数组 (Array of Arrays)
在 Go 中，我们可以使用数组的数组来创建多维数组。这种方式创建的多维数组在内存中是连续存储的，因此访问效率较高。
package main
import "fmt"
func main() {
fmt.Println("Array of Arrays")
a := [2][2]int{{0, 1}, {2, 3}}
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])
}
}
}优点：
- 内存连续，访问效率高。
- 内存占用相对较小，尤其是在维度和大小固定的情况下。
缺点：
Demila数字内容交易系统
下载
感谢使用Demila。Demila是一款由9秒社团原创的、面向数字内容及其服务的、优美的在线交易系统，她除了能为站长提供一个建站解决方案之外，还能为那些技术精湛的设计者、开发者以及资源拥有者们提供无数个拓展其作品和资源之价值的机会，从而使那些精益求精者的智慧和创意，无论是价格，还是价值，都达到应有的尺度。这是9秒社团Demila项目组的宗旨，也是Demila的使命。我们热切希望能有更多的人为Dem
- 大小固定，灵活性较差。在声明时必须指定所有维度的大小。
- 作为函数参数传递时，会进行值拷贝，可能导致性能问题。
切片的切片 (Slice of Slices)
另一种创建多维数组的方式是使用切片的切片。切片是 Go 中一种动态数组，因此切片的切片可以创建大小可变的多维数组。
package main
import "fmt"
func main() {
fmt.Println("Slice of Slices")
b := [][]int{{0, 1}, {2, 3}}
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])
}
}
}优点：
- 大小可变，灵活性高。可以动态调整每个维度的大小。
- 作为函数参数传递时，传递的是切片的引用，避免了值拷贝，提高了性能。
缺点：
- 内存不连续，访问效率相对较低。每个子切片都可能在不同的内存地址上分配。
- 内存占用相对较大，因为需要额外的空间存储切片的头部信息。
内存使用对比
以下代码展示了创建相同大小的数组的数组和切片的切片，并比较了它们的内存使用情况。
package main
import "fmt"
import "runtime"
func printMemUsage() {
var m runtime.MemStats
runtime.ReadMemStats(&m)
fmt.Printf("Alloc = %v MiB", bToMb(m.Alloc))
fmt.Printf("\tTotalAlloc = %v MiB", bToMb(m.TotalAlloc))
fmt.Printf("\tSys = %v MiB", bToMb(m.Sys))
fmt.Printf("\tNumGC = %v\n", m.NumGC)
}
func bToMb(b uint64) uint64 {
return b / 1024 / 1024
}
func main() {
// Array of Arrays
fmt.Println("Array of Arrays")
printMemUsage()
a := [100000][3]int{{1,2,3},{4,5,6}}
printMemUsage()
_ = a
// Slice of Slices
fmt.Println("Slice of Slices")
printMemUsage()
b := [][]int{{1,2,3},{4,5,6}}
printMemUsage()
for i := 0; i < 100000 -2; i++ {
b = append(b, []int{1,2,3})
}
printMemUsage()
_ = b
}从输出结果可以看出，相同大小的数组的数组比切片的切片占用更少的内存。
函数参数传递
数组是值类型，当作为函数参数传递时，会进行值拷贝。这意味着在函数内部修改数组不会影响原始数组。切片是引用类型，当作为函数参数传递时，传递的是切片的引用。这意味着在函数内部修改切片会影响原始切片。
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) | 切片的切片 (Slice of Slices) |
|---|---|---|
| 大小 | 固定 | 可变 |
| 内存 | 连续 | 不连续 |
| 内存占用 | 较小 | 较大 |
| 灵活性 | 较低 | 较高 |
| 参数传递 | 值拷贝 | 引用传递 |
选择建议：
- 如果多维数组的大小在编译时已知且不会改变，则应选择数组的数组，以获得更高的性能和更低的内存占用。
- 如果多维数组的大小需要在运行时动态调整，或者需要更高的灵活性，则应选择切片的切片。
总而言之，理解数组的数组和切片的切片之间的差异，可以帮助开发者在 Go 语言中更有效地创建和使用多维数组，从而编写出更高效、更灵活的代码。
