在go语言中，处理自定义类型及其切片是常见的编程任务。然而，开发者有时会遇到一个关于切片中存储值类型与指针类型的混淆问题，这通常会导致编译错误。本教程将深入分析这一问题，提供解决方案，并探讨go切片背后的核心机制。
考虑以下Go代码，它定义了一系列结构体来模拟一个订单系统：
package main
import (
"fmt"
)
type Customer struct {
Id int64
Name string
}
type Order struct {
Id int64
Customer *Customer
Orderlines *[]Orderline // 注意这里：一个指向Orderline切片的指针
}
type Orderline struct {
Id int64
Product *Product
Amount int64
}
type Product struct {
Id int64
Modelnr string
Price float64
}
func (o *Order) total_amount() float64 {
// 实际的计算逻辑在此处实现
return 0.0
}
func main() {
c := Customer{1, "Customername"}
p1 := Product{30, "Z97", 9.95}
p2 := Product{31, "Z98", 25.00}
ol1 := Orderline{10, &p1, 2}
ol2 := Orderline{11, &p2, 6}
// 尝试将Orderline的指针放入Orderline切片
ols := []Orderline{&ol1, &ol2} // 错误发生在此处
o := Order{1, &c, &ols}
fmt.Println(o)
}当尝试运行上述代码时，Go编译器会抛出以下错误：
# command-line-arguments ./test.go:43: cannot use &ol1 (type *Orderline) as type Orderline in array element ./test.go:43: cannot use &ol2 (type *Orderline) as type Orderline in array element
这个错误信息清晰地指出了问题所在：我们试图将类型为 *Orderline（Orderline的指针）的值，放入一个期望存储 Orderline（Orderline的值类型）的切片中。Go语言是强类型语言，不允许这种隐式类型转换。
Go切片是类型敏感的。当你声明一个切片如 []Orderline 时，你明确告诉编译器这个切片将存储 Orderline 类型的值。这意味着切片中的每个元素都将是 Orderline 结构体的一个副本。
立即学习“go语言免费学习笔记（深入）”；
然而，在示例代码中，ol1 和 ol2 是通过值初始化后，我们又获取了它们的地址 (&ol1, &ol2)。这些地址的类型是 *Orderline，即指向 Orderline 结构体的指针。将 *Orderline 放入 []Orderline 中，就造成了类型不匹配。
解决这个问题的核心在于，如果切片需要存储指向特定类型实例的指针，那么切片的类型就应该明确声明为指针切片。即，将 []Orderline 或 *[]Orderline 改为 []*Orderline。
具体修改如下：
修改 Order 结构体中的 Orderlines 字段类型： 将 Orderlines *[]Orderline 修改为 Orderlines []*Orderline。
修改切片的初始化方式： 将 ols := []Orderline{&ol1, &ol2} 修改为 ols := []*Orderline{&ol1, &ol2}。 这样，ols 就被正确地声明为一个存储 *Orderline 类型的切片。
修正后的完整代码示例如下：
package main
import (
"fmt"
)
type Customer struct {
Id int64
Name string
}
type Order struct {
Id int64
Customer *Customer
Orderlines []*Orderline // 修正：改为存储Orderline指针的切片
}
type Orderline struct {
Id int64
Product *Product
Amount int64
}
type Product struct {
Id int64
Modelnr string
Price float64
}
func (o *Order) total_amount() float64 {
total := 0.0
if o.Orderlines != nil {
for _, ol := range *o.Orderlines { // 注意这里，如果Orderlines是*[]Orderline，需要解引用
if ol != nil && ol.Product != nil {
total += ol.Product.Price * float64(ol.Amount)
}
}
}
return total
}
func main() {
c := Customer{1, "Customername"}
p1 := Product{30, "Z97", 9.95}
p2 := Product{31, "Z98", 25.00}
ol1 := Orderline{10, &p1, 2}
ol2 := Orderline{11, &p2, 6}
// 修正：初始化为存储Orderline指针的切片
ols := []*Orderline{&ol1, &ol2}
// 创建Order实例，并传递ols的地址给Orderlines字段
// 注意：如果Orderlines字段是[]*Orderline，则直接赋值ols即可
// o := Order{1, &c, &ols} // 如果Orderlines是*[]*Orderline，则需要&ols
o := Order{1, &c, ols} // 修正：直接赋值切片，因为Orderlines字段现在是[]*Orderline
fmt.Println("Order ID:", o.Id)
fmt.Println("Customer Name:", o.Customer.Name)
for i, ol := range o.Orderlines {
fmt.Printf(" Orderline %d: Product %s (%.2f), Amount %d\n", i+1, ol.Product.Modelnr, ol.Product.Price, ol.Amount)
}
fmt.Printf("Total Amount: %.2f\n", o.total_amount())
}关于 append 的注意事项：
在原始问题中，还提到了尝试直接对 o.Orderlines 使用 append 失败的情况：
o := new(Order) o.Id = 1 o.Customer = &c append(o.Orderlines, &ol1, &ol2) // 抛出 "evaluated but not used"
即使 Orderlines 类型正确，append 函数在Go中是返回一个新的切片（可能指向新的底层数组）。因此，你需要将 append 的结果重新赋值给切片变量：
// 假设 Orderlines 字段是 []*Orderline o.Orderlines = append(o.Orderlines, &ol1, &ol2)
如果 o.Orderlines 初始为 nil，append 会创建一个新的切片并返回。
今客CRM客户管理系统主要是为了帮助企业解决在日常工作中遇到的客户管理等难题而开发，通过今客CRM客户管理系统可以对企业事务中的不同功能进行操作，用户通过自定义字段类型可以达到适合不同企业的需求。在今客客户关系管理系统中管理着一个企业最为完整的客户信息，全面的客户信息覆盖在企业的市场营销、销售和服务与技术支持等企业整个前端办公领域的各个环节里。它为企业带来附加价值是不可限量的。今客CRM客户管理系
11
理解Go切片的工作原理对于避免这类错误至关重要。
切片是值类型，但具有引用行为： 切片在Go中实际上是一个结构体（被称为切片头或切片header），它包含三个字段：
当一个切片作为函数参数传递时，传递的是这个切片头结构体的副本。这意味着函数内部会得到一个独立的 Ptr、Len 和 Cap。然而，这个副本的 Ptr 仍然指向与原始切片相同的底层数组。因此，通过函数内部的切片副本修改底层数组的元素，会反映到原始切片上。
func modifySlice(s []int) {
s[0] = 99 // 修改底层数组
s = append(s, 4, 5) // append可能导致底层数组重新分配，s现在指向新数组
fmt.Println("Inside func after append:", s)
}
func main() {
mySlice := []int{1, 2, 3}
fmt.Println("Before func:", mySlice) // [1 2 3]
modifySlice(mySlice)
fmt.Println("After func:", mySlice) // [99 2 3] - 注意mySlice的长度和容量未变，因为append操作只影响了函数内部的s副本
}从上述例子可以看出，s[0] = 99 的修改影响了 mySlice，但 append 操作（如果导致了扩容）则不会影响 mySlice 的长度和容量，因为 s 变量现在可能指向了一个新的底层数组。
底层数组的重分配与切片解耦： 当使用 append 函数向切片添加元素，并且切片的当前容量不足以容纳新元素时，Go运行时会执行以下操作：
这个过程是关键。如果一个切片 A 有一个副本 B（例如通过函数传参），并且 B 执行 append 导致了底层数组的重分配，那么 B 的 Ptr 会更新指向新的底层数组，而 A 的 Ptr 仍然指向旧的（未扩容的）底层数组。此时，切片 A 和 B 就“解耦”了，它们不再共享同一个底层数组。这就是为什么 append 函数通常需要将返回值重新赋值给切片变量的原因。
在Go语言中，*[]Type（指向切片的指针）的使用场景非常罕见，且通常表示对Go切片语义的某种误解，或者处理非常特殊的边界情况。
如前所述，[]Type 或 []*Type 本身已经具有足够的“引用”行为，即通过它们可以修改底层数组的元素。
只有当你需要在函数内部修改切片头本身（而不是仅仅修改切片元素或向切片追加元素），并且希望这些对切片头的修改（如重新分配一个全新的切片，或者改变其长度/容量）能够反映回调用者时，才需要使用 *[]Type。
例如：
func resetSlice(s *[]int) {
// 在函数内部彻底改变切片，使其指向一个新的、空的切片
*s = []int{}
// 或者 *s = make([]int, 0, 10)
}
func main() {
mySlice := []int{1, 2, 3}
fmt.Println("Before reset:", mySlice) // [1 2 3]
resetSlice(&mySlice)
fmt.Println("After reset:", mySlice) // []
}在这个例子中，resetSlice 函数需要接收 *[]int 才能将 mySlice 重新赋值为一个全新的切片。如果只是传入 []int，那么 *s = []int{} 只会影响函数内部的副本，而不会改变 main 函数中的 mySlice。
总结来说，对于大多数情况：
通过掌握这些概念，你将能更自信、更高效地在Go语言中处理切片和自定义类型，避免常见的陷阱。
以上就是Golang自定义类型切片与指针：理解值类型与引用行为的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告
收藏
收藏
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
495
