Go语言中动态尺寸数据结构的选择：数组与切片的深度解析

package main

import "fmt"

func main() {
    // 声明一个固定大小为5的整数数组
    var arr [5]int
    fmt.Println("Array:", arr) // 输出: Array: [0 0 0 0 0]

    // 尝试使用变量作为数组长度 (编译错误)
    // n := 5
    // var dynamicArr [n]int // 编译错误: non-constant array bound n
}

package main

import "fmt"

func main() {
    // 声明一个空的整数切片
    var s1 []int
    fmt.Println("Slice 1:", s1, "Length:", len(s1), "Capacity:", cap(s1)) // 输出: Slice 1: [] Length: 0 Capacity: 0

    // 使用 make 函数创建切片，指定长度和容量
    s2 := make([]int, 3, 5) // 长度为3，容量为5
    fmt.Println("Slice 2:", s2, "Length:", len(s2), "Capacity:", cap(s2)) // 输出: Slice 2: [0 0 0] Length: 3 Capacity: 5

    // 向切片追加元素，使其动态增长
    s2 = append(s2, 10, 20)
    fmt.Println("Slice 2 after append:", s2, "Length:", len(s2), "Capacity:", cap(s2)) // 输出: Slice 2 after append: [0 0 0 10 20] Length: 5 Capacity: 5

    s2 = append(s2, 30) // 超过容量，底层数组会重新分配
    fmt.Println("Slice 2 after more append:", s2, "Length:", len(s2), "Capacity:", cap(s2)) // 输出: Slice 2 after more append: [0 0 0 10 20 30] Length: 6 Capacity: 10 (容量通常翻倍)
}

type Matrix struct {
    n, m int       // n: 行数, m: 列数
    rows [][]int   // 存储矩阵数据的切片
}

package main

import "fmt"

// Matrix 定义了一个矩阵结构体
type Matrix struct {
    n, m int       // n: 行数, m: 列数
    rows [][]int   // 存储矩阵数据的切片
}

// NewMatrix 是一个构造函数，用于创建并初始化一个指定维度的矩阵
func NewMatrix(n, m int) (*Matrix, error) {
    if n <= 0 || m <= 0 {
        return nil, fmt.Errorf("矩阵维度必须为正数，得到 n=%d, m=%d", n, m)
    }

    // 创建外层切片，表示 n 行
    rows := make([][]int, n)

    // 为每一行创建内层切片，表示 m 列
    for i := range rows {
        rows[i] = make([]int, m)
    }

    return &Matrix{
        n:    n,
        m:    m,
        rows: rows,
    }, nil
}

// SetValue 设置矩阵指定位置的值
func (mat *Matrix) SetValue(row, col, val int) error {
    if row < 0 || row >= mat.n || col < 0 || col >= mat.m {
        return fmt.Errorf("索引越界：row=%d, col=%d (矩阵维度为 %dx%d)", row, col, mat.n, mat.m)
    }
    mat.rows[row][col] = val
    return nil
}

// GetValue 获取矩阵指定位置的值
func (mat *Matrix) GetValue(row, col int) (int, error) {
    if row < 0 || row >= mat.n || col < 0 || col >= mat.m {
        return 0, fmt.Errorf("索引越界：row=%d, col=%d (矩阵维度为 %dx%d)", row, col, mat.n, mat.m)
    }
    return mat.rows[row][col], nil
}

// PrintMatrix 打印矩阵内容
func (mat *Matrix) PrintMatrix() {
    fmt.Printf("Matrix (%dx%d):\n", mat.n, mat.m)
    for i := 0; i < mat.n; i++ {
        fmt.Println(mat.rows[i])
    }
}

func main() {
    // 创建一个 3x4 的矩阵
    matrix, err := NewMatrix(3, 4)
    if err != nil {
        fmt.Println("创建矩阵失败:", err)
        return
    }

    // 设置一些值
    matrix.SetValue(0, 0, 1)
    matrix.SetValue(0, 1, 2)
    matrix.SetValue(1, 2, 5)
    matrix.SetValue(2, 3, 9)

    // 打印矩阵
    matrix.PrintMatrix()

    // 获取值
    val, _ := matrix.GetValue(1, 2)
    fmt.Printf("Value at (1, 2): %d\n", val)

    // 尝试越界访问
    _, err = matrix.GetValue(3, 0)
    if err != nil {
        fmt.Println("越界访问错误:", err)
    }
}