如何使用Golang实现指针常量数组_Golang不可变数据引用实践

Go不支持指针常量数组，因const仅适用于基础类型，无法用于指针或复合类型；需用结构体封装并隐藏字段实现逻辑不可变。

Go 里没有指针常量数组这种东西

Go 语言不支持 const 修饰指针类型数组，也不能声明“指向常量的指针”或“指针本身为常量”的复合类型。你写不出类似 C 的 int *const arr[5] 或 const int *arr[5] 这种语法——Go 的 const 只能作用于基础值（int, string, uintptr 等），不能用于复合类型或指针类型本身。

想让指针数组“逻辑上不可变”，得靠封装和约定

常见做法是用结构体封装底层数组，并只暴露只读方法。关键点在于：避免暴露可寻址的指针字段，防止外部通过 &v[i] 修改目标值；同时不提供 setter 方法。

• []*int 底层切片可以被重新赋值（如 a = append(a, ptr)），所以必须用 struct 封装并隐藏字段
• 如果希望元素指向的值也不可变，需确保这些 *int 指向的是只读上下文中的变量（比如包级私有变量、初始化后不再修改的实例）
• 导出方法只返回拷贝或只读视图，例如 At(i int) *int 可以返回指针，但调用方仍可能解引用后修改值——这取决于原始数据是否真不可变

type IntPtrArray struct {
    data []*int
}

func NewIntPtrArray(vals ...int) *IntPtrArray {
    ptrs := make([]*int, len(vals))
    for i, v := range vals {
        ptrs[i] = &vals[i] // ❌ 错误：vals 是副本，地址无效
    }
    // ✅ 正确做法：分配新变量或使用传入的持久地址
    ptrs = make([]*int, len(vals))
    for i := range vals {
        ptrs[i] = &vals[i] // 仍错 —— vals 是参数副本
    }
    // 实际应由调用方保证生命周期，例如：
    //   xs := []int{1,2,3}
    //   ptrs := make([]*int, len(xs))
    //   for i := range xs { ptrs[i] = &xs[i] }
    return &IntPtrArray{data: ptrs}
}

// 安全只读访问
func (a *IntPtrArray) Len() int          { return len(a.data) }
func (a *IntPtrArray) At(i int) *int      { return a.data[i] }
func (a *IntPtrArray) Values() []int      {
    res := make([]int, len(a.data))
    for i, p := range a.data {
        if p != nil {
            res[i] = *p
        }
    }
    return res
}

为什么不能用 [N]*T + const？

Go 不允许对数组或切片类型使用 const 声明，因为 const 要求编译期确定的纯值，而指针值（哪怕是指向包级变量的）在编译期无法确定其地址（ASLR、加载基址等影响）。以下写法全部非法：

• const arr [3]*int = [3]*int{&x, &y, &z} → 编译错误：invalid array element type *int
• const ptr *int = &x → 编译错误：cannot take address of x（除非 x 是字符串字面量或某些特殊常量）
• var arr = [...]int{1,2,3}; const ptrs = [...]*int{&arr[0], &arr[1]} → &arr[i] 非常量表达式

真正可控的“不可变引用”实践建议

如果你的目标是数据引用稳定且内容不被意外修改，优先考虑：

• 用 sync.Map 或只读接口（如 interface{ Get(int) int }）抽象访问，而非暴露裸指针
• 把底层数据定义为包级 var，配合文档说明“只读”，并在测试中覆盖误修改场景
• 需要高性能只读遍历时，直接传递 []*T 切片，但确保其底层数组不被重切（例如不传 slice[1:] 后再修改原 slice）
• 若涉及跨 goroutine 共享，指针本身不是问题，但所指对象需同步控制——这时“不可变”往往意味着用 atomic.Value 或不可变结构体（如 struct{ x, y int }）替代可变指针

最易被忽略的一点：Go 中所谓“不可变引用”，真正难控的从来不是语法限制，而是指针所指内存的生命周期与所有权归属。别花时间模拟 C 式 const 语义，先理清谁 alloc、谁 free、谁负责不变性。