Go语言复杂数据结构：多维数组与嵌套切片深度解析

package main

import "fmt"

func main() {
    println("0. Array:")
    var a = [...]int{4, 5, 6, 7, 8, 9} // 基础数组
    fmt.Println(a, "\n")

    println("2. Array of arrays:")
    var b [4][len(a)]int // 定义一个包含4个 [len(a)]int 数组的数组
    for i := range b {
        b[i] = a // 将基础数组a的值拷贝到b的每个元素中
    }
    fmt.Println(b, "\n")
}

package main

import "fmt"

func main() {
    println("0. Array:")
    var a = [...]int{4, 5, 6, 7, 8, 9}
    fmt.Println(a, "\n")

    println("2. Array of arrays:")
    var b [4][len(a)]int
    for i := range b {
        b[i] = a
    }
    fmt.Println(b, "\n")

    println("3. Array of slices:")
    var d [len(b)][]int // 定义一个包含 len(b) 个 []int 切片的数组
    for i := range b {
        d[i] = b[i][:] // 将 b[i] 这个数组切片，生成一个 []int 类型的切片赋值给 d[i]
    }
    fmt.Println(d, "\n")
}

package main

import "fmt"

func main() {
    println("0. Array:")
    var a = [...]int{4, 5, 6, 7, 8, 9}
    fmt.Println(a, "\n")

    println("2. Array of arrays:")
    var b [4][len(a)]int
    for i := range b {
        b[i] = a
    }
    fmt.Println(b, "\n")

    println("4. Slice of arrays:")
    var c [][len(a)]int // 定义一个 []int 数组的切片
    c = b[:]             // 正确的赋值方式：将数组b切片，生成一个切片的数组
    fmt.Println(c, "\n")
}

package main

import "fmt"

func main() {
    println("0. Array:")
    var a = [...]int{4, 5, 6, 7, 8, 9}
    fmt.Println(a, "\n")

    println("2. Array of arrays:")
    var b [4][len(a)]int
    for i := range b {
        b[i] = a
    }
    fmt.Println(b, "\n")

    println("3. Array of slices:")
    var d [len(b)][]int
    for i := range b {
        d[i] = b[i][:]
    }
    fmt.Println(d, "\n")

    println("5. Slice of slices:")
    var e [][]int // 定义一个 []int 切片的切片
    e = d[:]      // 将数组d切片，生成一个 [][]int 类型的切片
    fmt.Println(e, "\n")
}

package main

import "fmt"

func main() {
    // 0. 基础数组：固定长度，值类型
    println("0. Array:")
    var a = [...]int{4, 5, 6, 7, 8, 9}
    fmt.Printf("a (Array): %v, Type: %T\n\n", a, a)

    // 1. 基础切片：动态长度，引用类型，是对底层数组a的视图
    println("1. Slice:")
    var as []int
    as = a[:] // 从数组a创建切片as
    fmt.Printf("as (Slice): %v, Type: %T\n\n", as, as)

    // 2. 数组的数组 (多维数组)：[N][M]Type
    // 整体是固定长度的数组，每个元素也是固定长度的数组
    println("2. Array of arrays:")
    var b [4][len(a)]int // 定义一个包含4个 [len(a)]int 数组的数组
    for i := range b {
        b[i] = a // 将数组a的值拷贝到b的每个子数组中
    }
    fmt.Printf("b (Array of arrays): %v, Type: %T\n\n", b, b)

    // 3. 数组的切片：[N][]Type
    // 整体是固定长度的数组，每个元素是一个切片
    println("3. Array of slices:")
    var d [len(b)][]int // 定义一个包含 len(b) 个 []int 切片的数组
    for i := range b {
        // b[i] 是一个 [len(a)]int 类型的数组
        // b[i][:] 将这个数组切片，生成一个 []int 类型的切片
        d[i] = b[i][:]
    }
    fmt.Printf("d (Array of slices): %v, Type: %T\n\n", d, d)

    // 4. 切片的数组：[][M]Type
    // 整体是动态长度的切片，每个元素是固定长度的数组
    println("4. Slice of arrays:")
    var c [][len(a)]int // 定义一个 []int 数组的切片
    // b[:] 将数组b切片，生成一个 [][]int 数组的切片
    // 注意：b[:][:] 是冗余的，因为对切片再次切片 s[:] == s
    c = b[:]
    fmt.Printf("c (Slice of arrays): %v, Type: %T\n\n", c, c)

    // 5. 切片的切片：[][]Type
    // 整体是动态长度的切片，每个元素也是动态长度的切片
    println("5. Slice of slices:")
    var e [][]int // 定义一个 []int 切片的切片
    // d[:] 将数组d切片，生成一个 [][]int 类型的切片
    e = d[:]
    fmt.Printf("e (Slice of slices): %v, Type: %T\n\n", e, e)

    // 验证切片操作的引用特性
    println("--- 验证引用特性 ---")
    fmt.Println("原始 d[0]:", d[0])
    d[0][0] = 99 // 修改 d[0] 的底层数据
    fmt.Println("修改 d[0][0] 后:")
    fmt.Println("d[0]:", d[0])
    fmt.Println("e[0]:", e[0]) // e[0] 也会反映这个修改，因为它们共享底层数据
    fmt.Println("b[0]:", b[0]) // b[0] 的底层数据也会被修改
    // 注意：a 是值拷贝给 b[i]，所以修改 b[0] 不会影响 a
    fmt.Println("a:", a)
}