package matrix

import (
    "errors"
    "strconv"
    "strings"
)

// Matrix matrix inteface
type Matrix interface {
    Rows() [][]int
    Cols() [][]int
    Set(r, c, val int) bool
}

// matrix implements the interface Matrix
type matrix struct {
    data [][]int
    rows int
    cols int
}

// New returns a valid matrix created from the input
func New(input string) (Matrix, error) {
    var m matrix
    rows := strings.Split(input, "n")
    for r, row := range rows {
        rowElements := strings.Fields(row)

        switch {
        case r == 0:
            m.rows, m.cols = len(rows), len(rowElements)
            matrix, err := allocateMemory(m.rows, m.cols)
            if err != nil {
                return invalidMatrix()
            }
            m.data = matrix
        case len(rowElements) != m.cols:
            return invalidMatrix()
        }

        for c, element := range rowElements {
            element, err := strconv.Atoi(element)
            if err != nil {
                return invalidMatrix()
            }
            m.data[r][c] = element
        }
    }
    return m, nil
}

// invalidMatrix returns the error indicating the
// provided matrix is invalid
func invalidMatrix() (Matrix, error) {
    return nil, errors.New("invalid matrix")
}

// allocateMemory allocates a 2D slice of int having size RxC
func allocateMemory(R, C int) ([][]int, error) {
    if R < 1 || C < 1 {
        return nil, errors.New("invalid matrix")
    }
    matrix := make([][]int, R)
    for r := range matrix {
        matrix[r] = make([]int, C)
    }
    return matrix, nil
}

// Set sets the given value at (r,c) in the matrix,
// if (r,c) belongs to the matrix.
func (m matrix) Set(r, c, val int) bool {
    switch {
    case r < 0 || c < 0:
        return false
    case r >= m.rows || c >= m.cols:
        return false
    default:
        m.data[r][c] = val
        return true
    }
}

// order defines the order the matrix to export
// two useful values are columnMajor and rowMajor
type order int

const (
    columnMajor order = iota
    rowMajor
)

// Cols returns columns of the matrix.
func (m matrix) Cols() [][]int {
    return m.export(columnMajor)
}

// Rows returns rows of the matrix.
func (m matrix) Rows() [][]int {
    return m.export(rowMajor)
}

// export return the matrix in the required order;
// either columnMajor or rowMajor.
func (m matrix) export(o order) [][]int {
    var matrix [][]int
    var err error
    switch o {
    case columnMajor:
        matrix, err = allocateMemory(m.cols, m.rows)
        if err != nil {
            return nil
        }
        for r, row := range m.data {
            for c, element := range row {
                matrix[c][r] = element
            }
        }
    case rowMajor:
        matrix, err = allocateMemory(m.rows, m.cols)
        if err != nil {
            return nil
        }
        for r, row := range m.data {
            copy(matrix[r], row)
        }
    }
    return matrix
}

我很难理解为什么 Set() 方法能够修改结构体的数据。我有一个理解，在值上定义的方法不能做到这一点。我试图将它与另一个我无法修改接收器内容的问题进行比较，但在这种情况下它可以正常工作。此代码的测试文件位于test file。知道我缺少什么吗？

回答

package main

import (
    "fmt"
)

type Holder struct {
    s []int
    v []int
}

func (h Holder) Set() {
    // This will successfully modify the `s` slice's contents
    h.s[0] = 99

    // This will assign a new slice to a copy of the v field,
    // so it won't affect the actual value on which this
    // method is invoked. 
    h.v = []int{1, 2, 3}
}

func main() {
    var h Holder
    h.s = []int{10, 20, 30}
    h.v = []int{40, 50, 60}

    fmt.Println("before Set:", h)
    
    h.Set()
    fmt.Println("after Set:", h)
}

before Set: {[10 20 30] [40 50 60]}
after Set: {[99 20 30] [40 50 60]}