Go语言结构体初始化与构造模式：从工厂函数到单例实现

package matrix

import "fmt"

// Matrix 定义了一个矩阵结构体
type Matrix struct {
    rows  int
    cols  int
    elems []float64 // 使用float64来存储元素
}

// NewMatrix 是一个工厂函数，用于创建并初始化一个Matrix实例
// 它接受行数和列数作为参数，返回一个指向新Matrix的指针
func NewMatrix(rows, cols int) *Matrix {
    if rows <= 0 || cols <= 0 {
        fmt.Printf("Error: Rows and columns must be positive. Got rows=%d, cols=%d\n", rows, cols)
        return nil // 或者返回错误
    }
    m := &Matrix{ // 使用复合字面量创建并初始化结构体
        rows:  rows,
        cols:  cols,
        elems: make([]float64, rows*cols),
    }
    // 可以在这里进行其他初始化操作
    return m
}

// GetRows 获取矩阵的行数
func (m *Matrix) GetRows() int {
    return m.rows
}

// GetCols 获取矩阵的列数
func (m *Matrix) GetCols() int {
    return m.cols
}

// 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
}

// 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
}

// 示例用法：
/*
func main() {
    m := NewMatrix(3, 4)
    if m != nil {
        fmt.Printf("Created a %dx%d matrix.\n", m.GetRows(), m.GetCols())
        m.SetElement(0, 0, 1.0)
        val, _ := m.GetElement(0, 0)
        fmt.Printf("Element at (0,0): %f\n", val)
    }
}
*/

package main

import (
    "fmt"
    "net/http"
)

// myOwnRouter 实现了 http.Handler 接口
type myOwnRouter struct {
    // 可以在这里添加路由器的内部状态或配置
    name string
}

// ServeHTTP 是 http.Handler 接口的方法
func (mor *myOwnRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello from %s!", mor.name)
}

// NewMyOwnRouter 是一个工厂函数，用于创建并初始化 myOwnRouter 实例
// 它可以接受初始化参数，例如路由器的名称
func NewMyOwnRouter(name string) *myOwnRouter {
    return &myOwnRouter{
        name: name,
    }
}

func init() {
    // 使用工厂函数创建实例并注册
    http.Handle("/", NewMyOwnRouter("MyCustomRouter"))
    // ... 其他路由注册
}

/*
func main() {
    // 在 main 函数中启动 HTTP 服务器
    // http.ListenAndServe(":8080", nil)
}
*/

package singleton

import (
    "fmt"
)

// myOwnRouter 结构体，作为单例对象
type myOwnRouter struct {
    // 可以在这里添加路由器的内部状态
    config string
}

// instantiated 是 myOwnRouter 的唯一实例
var instantiated *myOwnRouter = nil

// NewMyOwnRouter 是获取 myOwnRouter 单例的函数
// 注意：此版本非线程安全，不建议在并发环境中使用
func NewMyOwnRouter() *myOwnRouter {
    if instantiated == nil {
        fmt.Println("Initializing myOwnRouter singleton (non-thread-safe)...")
        instantiated = &myOwnRouter{
            config: "default_config",
        }
    } else {
        fmt.Println("Returning existing myOwnRouter singleton (non-thread-safe)...")
    }
    return instantiated
}

// GetConfig 获取配置信息
func (mor *myOwn