Go语言：结构体实例化与单例模式的惯用设计

package matrix

import "fmt"

// Matrix 表示一个矩阵结构体
type Matrix struct {
    rows  int
    cols  int
    elems []float64 // 存储矩阵元素
}

// NewMatrix 是一个构造器函数，用于创建并初始化一个Matrix实例
func NewMatrix(rows, cols int) *Matrix {
    if rows <= 0 || cols <= 0 {
        fmt.Printf("Error: rows and columns must be positive. Got %d, %d\n", rows, cols)
        return nil // 或者返回一个错误
    }
    m := new(Matrix) // 分配Matrix的内存并返回其指针
    m.rows = rows
    m.cols = cols
    m.elems = make([]float64, rows*cols) // 初始化底层切片
    return m
}

// GetElement 获取矩阵指定位置的元素
func (m *Matrix) GetElement(row, col int) (float64, error) {
    if row < 0 || row >= m.rows || col < 0 || col >= m.cols {
        return 0, fmt.Errorf("index out of bounds: (%d, %d) for matrix %dx%d", row, col, m.rows, m.cols)
    }
    return m.elems[row*m.cols+col], nil
}

// SetElement 设置矩阵指定位置的元素
func (m *Matrix) SetElement(row, col int, value float64) error {
    if row < 0 || row >= m.rows || col < 0 || col >= m.cols {
        return fmt.Errorf("index out of bounds: (%d, %d) for matrix %dx%d", row, col, m.rows, m.cols)
    }
    m.elems[row*m.cols+col] = value
    return nil
}

func main() {
    // 使用构造器创建Matrix实例
    myMatrix := NewMatrix(3, 4)
    if myMatrix != nil {
        fmt.Println("Matrix created successfully:", myMatrix)
        myMatrix.SetElement(0, 0, 1.1)
        val, _ := myMatrix.GetElement(0, 0)
        fmt.Println("Element (0,0):", val)
    }

    invalidMatrix := NewMatrix(-1, 2)
    if invalidMatrix == nil {
        fmt.Println("Invalid matrix creation handled.")
    }
}

package singleton

import (
    "fmt"
    "net/http"
    "sync"
)

// myOwnRouter 定义一个简单的HTTP路由器结构体
type myOwnRouter struct {
    // 可以在这里添加路由相关的字段，例如一个路由映射
}

// ServeHTTP 实现了http.Handler接口
func (mor *myOwnRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello from my own Router! Request Path: %s\n", r.URL.Path)
}

// instantiated 是包级别的变量，用于存储myOwnRouter的唯一实例
var instantiated *myOwnRouter = nil
var once sync.Once // 用于确保初始化操作只执行一次

// GetMyOwnRouter 是单例模式的访问函数
// 它确保myOwnRouter只被实例化一次
func GetMyOwnRouter() *myOwnRouter {
    once.Do(func() {
        // 只有在第一次调用时才会执行这里的代码
        instantiated = &myOwnRouter{} // 或者 new(myOwnRouter)
        fmt.Println("myOwnRouter instance created.")
    })
    return instantiated
}

// 示例用法
func main() {
    // 获取单例实例并注册到HTTP服务器
    routerInstance := GetMyOwnRouter()
    http.Handle("/", routerInstance)

    // 再次获取，会返回同一个实例
    anotherRouterInstance := GetMyOwnRouter()
    if routerInstance == anotherRouterInstance {
        fmt.Println("Both router instances are the same (singleton).")
    }

    fmt.Println("Server starting on :8080")
    // http.ListenAndServe(":8080", nil) // 启动HTTP服务器
    // 为了演示，这里不实际启动服务器
}