golang指针使用

1. 指针作为函数参数

go语言中指针作为函数参数时基本和C语言相同。先看代码

1. package main
3. import (
4.    "fmt"
5. )
7. func UpdateA(x int) {
8.    x = 5
9. }
11. func UpdateB(x *int) {
12.    //x = 5 //compile error
13.    *x = 5
14. }
16. func main() {
17.    a := 4
18.    UpdateA(a)
19.    fmt.Printf("a = %d\n", a)
21.    b := 4
22.    //UpdateB(b) //compile error
23.    UpdateB(&b)
24.    fmt.Printf("b = %d\n", b)
25. }

运行

1. # go run func.go
2. a = 4
3. b = 5

2. 方法中的指针

go语言的结构体类似于C++中的类，可以包含属性和方法。
如：

1. package main
3. import (
4.    "fmt"
5. )
7. type Cat struct {
8.    age int
9. }
11. func (cat Cat) Age() int {
12.    return cat.age
13. }

代码中创建了一个Cat结构体，其中age是结构体的属性，Age()是结构体方法。

给对象分配内存可以用如下几种方式：

1. cat := new(Cat) //返回Cat对象指针
2. cat := &Cat{1} //内部会调用new(Cat)，返回Cat对象指针
3. cat := Cat{1} //返回Cat对象

但是，如果Cat结构体中有指针方法，就只能创建Cat对象指针
给上面的Cat结构体添加一个指针方法：

1. func (cat *Cat) SetAge(x int) {
2.    cat.age = x
3. }

go编译器规定此时只能创建Cat对象指针，如果创建Cat对象会出错：

1. cat := Cat{1} //compile error

3. 调用方法时的指针使用

对于方法的调用，go和C++不同，go比较智能，指针方法和值方法都可以通过指针或非指针对象调用。例如：

1. type Cat struct {
2.    age int
3. }
5. func (cat Cat) Age() int {
6.    return cat.age
7. }
9. func main() {
10.    cat := new(Cat) //返回Cat对象指针
11.    age := cat.Age()//同age := (*cat).Age()
12.    fmt.Printf("%d\n", age)
13. }

代码中定义了结构体Cat的Age()方法，通过关键词new生成一个Cat对象指针，我们可以通过cat.Age()或(*cat).Age()访问Age()方法。

如果代码修改成：

1. func (cat *Cat) Age() int {
2.    return cat.age
3. }
5. func main() {
6.    cat := Cat{age:1} //返回Cat对象
7.    age := cat.Age()//同age := (&cat).Age()
8.    fmt.Printf("%d\n", age)
9. }

结构体Cat定义了指针方法Age()，main()函数中生成了一个Cat的对象cat，可以通过cat.Age()或(&cat).Age()访问Age()指针方法。

可见，go语言中结构体调用方法是很灵活的，编译过程中会自动完成转换。

4. 指针方法和值方法

和函数类似，指针方法可以修改结构体中的属性值，值方法由于传递的参数是结构体对象的副本，不能改变其属性值。测试代码如下：

1. package main
3. import (
4.    "fmt"
5. )
7. type Cat struct {
8.    age int
9. }
11. func (cat Cat) Age() int {
12.    return cat.age
13. }
15. func (cat Cat) SetAge(x int) {
16.    cat.age = x
17. }
19. type Dog struct {
20.    age int
21. }
23. func (dog Dog) Age() int {
24.    return dog.age
25. }
27. func (dog *Dog) SetAge(x int) {
28.    dog.age = x
29. }
31. func main() {
32.    cat := new(Cat)
33.    cat.SetAge(5)
34.    fmt.Printf("%d\n", cat.Age())
36.    dog := new(Dog)
37.    dog.SetAge(5)
38.    fmt.Printf("%d\n", dog.Age())
39. }

运行：

1. # go run struct.go
2. 0
3. 5

cat的age没被修改，所以是默认初始值0，dog的age被修改了。


以上就是go语言中指针使用的简单说明，总体来说go的指针处理比C语言规则更宽松，但个人感觉这反而容易让初学者混淆。