Go 指针的使用
在Go语言中，指针（Pointer）是一种能够存储变量地址的数据类型。Go的指针使用比较简单，并且避免了许多其他编程语言中的复杂性，比如指针算术运算。指针的使用可以提高程序性能（避免不必要的复制），也可以用于共享数据，传递引用。
1. 指针的基础知识
在Go中，指针通过*符号声明，通过&符号获取变量的地址。
示例 1：指针的声明和使用
package main
import "fmt"
func main() {
var x int = 10
var p *int = &x // 获取变量 x 的地址，并赋值给指针 p
fmt.Println("x 的值:", x) // 输出: x 的值: 10
fmt.Println("p 指向的值:", *p) // 输出: p 指向的值: 10
fmt.Println("x 的地址:", p) // 输出 x 的地址
}
在这个例子中：
&x返回变量x的内存地址。p是一个指向x的指针，类型为*int，表示p存储的是一个整数变量的地址。*p表示p指向的变量的值，即x的值。
2. 指针修改变量的值
指针允许我们通过引用修改变量的值，尤其在函数传参时非常有用。默认情况下，Go的参数传递是值传递，这意味着在函数中会生成参数的副本。如果希望函数可以直接修改传入的变量，就可以使用指针参数。
示例 2：通过指针修改变量值
package main
import "fmt"
func updateValue(x *int) {
*x = 20 // 修改指针 x 指向的变量的值
}
func main() {
var num int = 10
fmt.Println("修改前 num 的值:", num) // 输出: 修改前 num 的值: 10
updateValue(&num) // 传递 num 的地址
fmt.Println("修改后 num 的值:", num) // 输出: 修改后 num 的值: 20
}
在这个例子中：
updateValue函数接收一个指针*int作为参数，允许它修改原始变量的值。- 在
main函数中，我们传递了变量num的地址&num给updateValue，使得num的值在函数中被直接修改。
3. 指针与结构体
指针在操作结构体时非常有用。通过结构体指针，我们可以避免复制结构体的数据，从而节省内存和提高效率。
示例 3：结构体指针
package main
import "fmt"
// 定义结构体 Person
type Person struct {
Name string
Age int
}
// 修改结构体字段的函数
func updatePerson(p *Person) {
p.Name = "Alice" // 直接修改指针 p 指向的 Person 结构体的字段
p.Age = 25
}
func main() {
person := Person{Name: "Bob", Age: 20}
fmt.Println("修改前:", person) // 输出: 修改前: {Bob 20}
updatePerson(&person) // 传递结构体的指针
fmt.Println("修改后:", person) // 输出: 修改后: {Alice 25}
}
在这个例子中：
updatePerson函数接收一个*Person类型的参数，能够直接修改Person结构体的字段。- 在
main中，我们通过&person传递person的地址，因此函数可以直接修改person的字段。
4. 指针数组与数组指针
Go语言中有指向数组的指针（数组指针），以及包含指针的数组（指针数组）。这两个概念是不同的。
示例 4：指针数组与数组指针
package main
import "fmt"
func main() {
// 指针数组：数组中的每个元素都是一个指针
a, b := 10, 20
ptrArray := [...]*int{&a, &b}
fmt.Println("指针数组 ptrArray:", ptrArray) // 输出: 指针数组 ptrArray: [0xc0000180d0 0xc0000180e0]
// 数组指针：一个指向数组的指针
arr := [2]int{30, 40}
var ptrToArray *[2]int = &arr
fmt.Println("数组指针 ptrToArray:", ptrToArray) // 输出: 数组指针 ptrToArray: &[30 40]
}
在这个例子中：
ptrArray是一个指针数组，它的元素是指向int类型变量的指针。ptrToArray是一个数组指针，指向一个包含两个int元素的数组arr。
5. 指针与方法
在Go中，结构体的方法接收者可以是值类型，也可以是指针类型。当方法接收者是指针时，可以在方法内部修改结构体的字段。
示例 5：方法中的指针接收者
package main
import "fmt"
// 定义结构体 Rectangle
type Rectangle struct {
Width, Height int
}
// 定义指针接收者方法，用于修改字段
func (r *Rectangle) Scale(factor int) {
r.Width *= factor
r.Height *= factor
}
// 定义值接收者方法，仅用于计算面积，不修改字段
func (r Rectangle) Area() int {
return r.Width * r.Height
}
func main() {
rect := Rectangle{Width: 10, Height: 5}
fmt.Println("原始尺寸:", rect) // 输出: 原始尺寸: {10 5}
fmt.Println("原始面积:", rect.Area()) // 输出: 原始面积: 50
rect.Scale(2) // 修改尺寸
fmt.Println("放大后尺寸:", rect) // 输出: 放大后尺寸: {20 10}
fmt.Println("放大后面积:", rect.Area()) // 输出: 放大后面积: 200
}
在这个例子中：
Scale方法使用了指针接收者*Rectangle，因此可以直接修改结构体的字段。Area方法使用了值接收者Rectangle，它不会修改结构体的字段，只返回计算结果。
6. 避免指针的空引用
在Go语言中，使用指针时要小心空指针引用。当指针未初始化时，它的默认值为nil。在访问空指针时，会导致运行时错误（nil pointer dereference）。
示例 6：空指针检查
package main
import "fmt"
// 定义结构体 Person
type Person struct {
Name string
}
// 定义一个函数接收指针
func printName(p *Person) {
if p == nil {
fmt.Println("空指针，无法访问属性")
return
}
fmt.Println("Name:", p.Name)
}
func main() {
var p *Person // p 为 nil
printName(p) // 输出: 空指针，无法访问属性
p = &Person{Name: "Alice"}
printName(p) // 输出: Name: Alice
}
在这个例子中：
printName函数检查指针p是否为nil，以避免空指针引用的错误。
7. 接口中指针的使用
在Go语言中，接口（interface）是用来定义方法集合的类型，任何实现了接口中所有方法的类型，都可以作为该接口的实例。“接口指针”通常指的是将指针类型赋值给接口，或将接口指针传递给函数的情况。Go语言中没有“接口指针”这一特定类型，但是在使用接口时，可以通过指针接收者和接口变量来实现类似指针的行为和灵活性。
7.1. 接口类型和结构体指针的组合使用
在Go语言中，结构体可以实现接口。如果希望在实现接口的方法中修改结构体的状态，一般会使用结构体的指针接收者来实现接口。
示例 1：接口与结构体指针的实现
package main
import "fmt"
// 定义接口 Shape
type Shape interface {
Area() float64
Scale(factor float64)
}
// 定义结构体 Circle
type Circle struct {
Radius float64
}
// 使用指针接收者实现接口方法 Area
func (c *Circle) Area() float64 {
return 3.14 * c.Radius * c.Radius
}
// 使用指针接收者实现接口方法 Scale，可以修改结构体的字段
func (c *Circle) Scale(factor float64) {
c.Radius *= factor
}
func main() {
// 创建 Circle 结构体实例，并将其指针赋值给接口类型变量
var s Shape = &Circle{Radius: 5}
fmt.Println("初始面积:", s.Area()) // 输出: 初始面积: 78.5
s.Scale(2) // 使用接口方法修改半径
fmt.Println("放大后面积:", s.Area()) // 输出: 放大后面积: 314
}
在这个例子中：
Shape接口定义了Area和Scale方法。Circle结构体通过指针接收者实现了Shape接口的方法。- 在
main函数中，我们将&Circle{Radius: 5}指针赋给接口变量s。由于Scale方法接收的是指针，可以通过接口直接修改Circle的Radius字段。
7.2. 将结构体指针赋值给接口变量
当我们将结构体指针赋值给接口变量时，接口变量会持有结构体的指针，因此可以调用接口方法并影响原始数据。
示例 2：结构体指针赋值给接口
package main
import "fmt"
// 定义接口 Printer
type Printer interface {
Print()
}
// 定义结构体 Document
type Document struct {
Content string
}
// 使用指针接收者实现接口方法 Print
func (d *Document) Print() {
fmt.Println("内容:", d.Content)
}
func main() {
doc := &Document{Content: "Hello, Go!"}
var p Printer = doc // 将结构体指针赋值给接口
p.Print() // 输出: 内容: Hello, Go!
}
在这个例子中：
Document结构体实现了Printer接口。doc是*Document类型的变量，将其赋值给接口变量p后，p可以调用Document的Print方法。
7.3. 接口指针作为函数参数
接口指针在作为函数参数时很有用，因为它可以动态地接收实现了该接口的任何类型的值（包括指针）。这样可以通过接口实现多态。
示例 3：接口指针作为函数参数
package main
import "fmt"
// 定义接口 Notifier
type Notifier interface {
Notify(message string)
}
// 定义结构体 User
type User struct {
Name string
}
// 使用指针接收者实现接口方法 Notify
func (u *User) Notify(message string) {
fmt.Printf("用户 %s 收到消息: %s\n", u.Name, message)
}
// 定义一个发送通知的函数，接收 Notifier 接口
func SendNotification(n Notifier, message string) {
n.Notify(message)
}
func main() {
u := &User{Name: "Alice"}
SendNotification(u, "欢迎使用我们的服务!") // 输出: 用户 Alice 收到消息: 欢迎使用我们的服务!
}
在这个例子中：
User结构体实现了Notifier接口的Notify方法。SendNotification函数接收一个Notifier接口作为参数，可以将任何实现了Notifier接口的类型传入。u是*User类型，满足Notifier接口，可以作为参数传递给SendNotification。
7.4. 指针接收者与接口的区别
指针接收者和值接收者的区别
package main
import "fmt"
type Speaker interface {
Speak()
}
type Person struct {
Name string
}
// 值接收者实现接口方法 Speak
func (p Person) Speak() {
fmt.Println("Hello, I am", p.Name)
}
// 指针接收者实现接口方法 Speak
func (p *Person) SpeakLoud() {
fmt.Println("HELLO, I AM", p.Name)
}
func main() {
p := Person{Name: "Bob"}
// 使用值接收者实现接口，可以直接赋值结构体实例
var s Speaker = p
s.Speak() // 输出: Hello, I am Bob
// 使用指针接收者实现接口，只能赋值结构体指针
var sLoud Speaker = &p
sLoud.Speak() // 输出: HELLO, I AM Bob
}
在这个例子中：
Speak方法使用值接收者，允许接口变量接收Person结构体的值。SpeakLoud方法使用指针接收者，因此接口变量只能接收指向Person的指针。
7.5. 接口的nil与接口指针的比较
在Go中，接口变量的nil状态有时会比较复杂。接口变量本身可以是nil，或者接口变量指向的值可以是nil，这在实际开发中需要特别注意。
接口的nil使用
package main
import "fmt"
type Reader interface {
Read() string
}
type FileReader struct {
content string
}
func (f *FileReader) Read() string {
return f.content
}
func main() {
var r Reader // 接口变量为 nil
fmt.Println("接口 r 是否为 nil:", r == nil) // 输出: 接口 r 是否为 nil: true
// 当接口变量指向一个 nil 值时，接口本身不为 nil
var fr *FileReader = nil
r = fr
fmt.Println("fr 是否为 nil:", fr == nil) // 输出: fr 是否为 nil: true
fmt.Println("接口 r 是否为 nil:", r == nil) // 输出: 接口 r 是否为 nil: false
}
在这个例子中：
声明了一个 *FileReader 类型的指针变量 fr 并初始化为 nil，表示它没有指向任何有效的 FileReader 实例。然后将 fr 赋值给了 r。
虽然 fr 本身是一个 nil 指针，但是当它被赋值给 r 之后，r 就不再是 nil 了，因为 r 现在包含了一个类型信息（即 *FileReader），即使它的值部分是 nil。
再次检查 fr 和 r 是否为 nil，fr 仍然是 nil，因为没有分配实际的 FileReader 实例给它。
而 r 不再是 nil，因为即使它的值部分是 nil，它仍然持有了一个具体的类型信息。
这里的关键点在于理解Go语言中接口的内部结构：接口实际上是由两部分组成的，一部分是值，另一部分是值的类型。当一个接口变量被赋予一个具体类型的值时，即使这个值是 nil，接口变量也不再是 nil，因为它已经持有了类型信息。只有当接口变量完全没有任何类型和值信息时，它才是 nil。
8. Go中不支持指针运算
与C和C++不同，Go不允许对指针进行算术运算（例如，不能对指针进行加减操作）。这种设计使得Go语言中的指针更加安全，减少了因指针运算导致的错误。
- 指针声明和使用：使用
*声明指针类型，使用&获取变量地址。 - 通过指针修改值：函数接收指针参数，可以直接修改变量的值。
- 结构体指针：在函数或方法中使用结构体指针，可以避免复制结构体数据，提高性能。
- 指针数组与数组指针：指针数组是数组中的元素为指针，而数组指针是指向整个数组的指针。
- 方法中的指针接收者：指针接收者方法可以修改结构体的字段，值接收者方法不会修改结构体字段。
- “接口指针”通常指的是将指针类型赋值给接口，或将接口指针传递给函数的情况。Go语言中没有“接口指针”这一特定类型，但是在使用接口时，可以通过指针接收者和接口变量来实现类似指针的行为和灵活性。
- 空指针检查：在使用指针前检查是否为
nil，避免空指针错误。
Go中的指针机制简洁但功能强大，帮助实现内存高效的代码设计。
原文地址：https://blog.csdn.net/weixin_44719499/article/details/143594192
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！