Golang项目开发遇到问题，求大神帮忙解决

以下是基于您需求的完整Go程序实现。我重构了代码结构，使用切片替代固定数组，并实现了所有必需功能：

package main

import (
	"fmt"
	"math"
	"os"
	"os/exec"
	"runtime"
)

type Spreadsheet struct {
	rows [][]float64
	ops  []string
	calc []float64
}

func NewSpreadsheet(rows, cols int) *Spreadsheet {
	s := &Spreadsheet{
		rows: make([][]float64, rows),
		ops:  make([]string, rows),
		calc: make([]float64, rows),
	}
	
	for i := range s.rows {
		s.rows[i] = make([]float64, cols)
		s.ops[i] = "SUM" // 默认操作
	}
	return s
}

func (s *Spreadsheet) calculateRow(rowIndex int) {
	row := s.rows[rowIndex]
	
	switch s.ops[rowIndex] {
	case "SUM":
		sum := 0.0
		for _, val := range row {
			sum += val
		}
		s.calc[rowIndex] = sum
	case "AVERAGE":
		sum := 0.0
		for _, val := range row {
			sum += val
		}
		if len(row) > 0 {
			s.calc[rowIndex] = sum / float64(len(row))
		} else {
			s.calc[rowIndex] = 0
		}
	case "MIN":
		min := math.MaxFloat64
		for _, val := range row {
			if val < min {
				min = val
			}
		}
		if min == math.MaxFloat64 {
			s.calc[rowIndex] = 0
		} else {
			s.calc[rowIndex] = min
		}
	case "MAX":
		max := -math.MaxFloat64
		for _, val := range row {
			if val > max {
				max = val
			}
		}
		if max == -math.MaxFloat64 {
			s.calc[rowIndex] = 0
		} else {
			s.calc[rowIndex] = max
		}
	}
}

func (s *Spreadsheet) PrintAll() {
	for i := range s.rows {
		s.PrintRow(i)
	}
}

func (s *Spreadsheet) PrintRow(rowIndex int) {
	fmt.Printf("%d:", rowIndex+1)
	for _, value := range s.rows[rowIndex] {
		fmt.Printf("%8.2f ", value)
	}
	fmt.Printf(" | %8.2f (%s)\n", s.calc[rowIndex], s.ops[rowIndex])
}

func (s *Spreadsheet) EditCell(rowIndex, colIndex int) {
	if rowIndex < 0 || rowIndex >= len(s.rows) || colIndex < 0 || colIndex >= len(s.rows[0]) {
		fmt.Println("无效的行或列索引")
		return
	}
	
	fmt.Printf("输入新值 (当前值=%.2f): ", s.rows[rowIndex][colIndex])
	var newValue float64
	_, err := fmt.Scanln(&newValue)
	if err != nil {
		fmt.Println("无效输入，请输入数字")
		var discard string
		fmt.Scanln(&discard)
		return
	}
	
	s.rows[rowIndex][colIndex] = newValue
	s.calculateRow(rowIndex)
}

func (s *Spreadsheet) ChangeOperation(rowIndex int) {
	if rowIndex < 0 || rowIndex >= len(s.ops) {
		fmt.Println("无效的行索引")
		return
	}
	
	fmt.Println("选择操作:")
	fmt.Println("1: SUM (求和)")
	fmt.Println("2: AVERAGE (平均值)")
	fmt.Println("3: MIN (最小值)")
	fmt.Println("4: MAX (最大值)")
	fmt.Print("你的选择 (1-4): ")
	
	var choice int
	_, err := fmt.Scanln(&choice)
	if err != nil || choice < 1 || choice > 4 {
		fmt.Println("无效选择")
		var discard string
		fmt.Scanln(&discard)
		return
	}
	
	switch choice {
	case 1:
		s.ops[rowIndex] = "SUM"
	case 2:
		s.ops[rowIndex] = "AVERAGE"
	case 3:
		s.ops[rowIndex] = "MIN"
	case 4:
		s.ops[rowIndex] = "MAX"
	}
	
	s.calculateRow(rowIndex)
}

func (s *Spreadsheet) ClearRow(rowIndex int) {
	if rowIndex < 0 || rowIndex >= len(s.rows) {
		fmt.Println("无效的行索引")
		return
	}
	
	for i := range s.rows[rowIndex] {
		s.rows[rowIndex][i] = 0
	}
	s.calculateRow(rowIndex)
	fmt.Printf("行 %d 已清空\n", rowIndex+1)
}

func (s *Spreadsheet) ClearAll() {
	for i := range s.rows {
		for j := range s.rows[i] {
			s.rows[i][j] = 0
		}
		s.calculateRow(i)
	}
	fmt.Println("所有行已清空")
}

func ClearScreen() {
	var cmd *exec.Cmd
	switch runtime.GOOS {
	case "windows":
		cmd = exec.Command("cmd", "/c", "cls")
	default:
		cmd = exec.Command("clear")
	}
	cmd.Stdout = os.Stdout
	cmd.Run()
}

func getValidIntInput(prompt string, min, max int) int {
	for {
		fmt.Print(prompt)
		var input int
		_, err := fmt.Scanln(&input)
		if err != nil || input < min || input > max {
			fmt.Printf("无效输入，请输入 %d 到 %d 之间的数字\n", min, max)
			var discard string
			fmt.Scanln(&discard)
			continue
		}
		return input
	}
}

func main() {
	spreadsheet := NewSpreadsheet(5, 5)
	
	for {
		ClearScreen()
		fmt.Println("=== 电子表格程序 ===")
		spreadsheet.PrintAll()
		fmt.Println("\n菜单选项:")
		fmt.Println("[1] 编辑单元格")
		fmt.Println("[2] 更改行操作")
		fmt.Println("[3] 清空单行")
		fmt.Println("[4] 清空所有行")
		fmt.Println("[5] 退出程序")
		
		choice := getValidIntInput("\n你的选择: ", 1, 5)
		
		switch choice {
		case 1:
			row := getValidIntInput("行号? (1-5): ", 1, 5) - 1
			col := getValidIntInput("列号? (0-4): ", 0, 4)
			spreadsheet.EditCell(row, col)
		case 2:
			row := getValidIntInput("行号? (1-5): ", 1, 5) - 1
			spreadsheet.ChangeOperation(row)
		case 3:
			row := getValidIntInput("行号? (1-5): ", 1, 5) - 1
			spreadsheet.ClearRow(row)
		case 4:
			spreadsheet.ClearAll()
		case 5:
			fmt.Println("程序退出")
			return
		}
		
		fmt.Print("按回车键继续...")
		fmt.Scanln()
	}
}

主要改进点：

1. 使用结构体封装：创建了Spreadsheet结构体来管理所有数据
2. 动态计算：实现了calculateRow方法，根据操作类型计算每行的结果
3. 输入验证：添加了getValidIntInput函数处理无效输入
4. 完整的操作支持：实现了所有必需的操作（求和、平均值、最小值、最大值）
5. 健壮的错误处理：防止数组越界和无效输入

程序运行时会显示5行数据，每行包含5个单元格，右侧显示基于选定操作的计算结果。用户可以通过菜单进行各种操作，所有输入都经过验证以确保程序稳定性。