关于golang指针的理解与使用

本文详细介绍了Go语言中的指针概念,指出了Go指针与普通变量的区别,强调了没有指针运算的特点。文章通过实例解析了指针的使用,特别是在方法中的应用,讨论了何时选择指针或普通变量作为参数。最后,文章总结了指针的零值和初始化,以及在函数方法中如何合理选择指针类型。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Go指针理解

Go 有指针,但是没有指针运算。你不能用指针变量遍历字符串的各个字节。在 Go 中调用函数的时候,得记得变量是值传递的。

通过类型作为前缀来定义一个指针’ * ’:var p * int。现在 p 是一个指向整数值的指针。所有新定义的变量都被赋值为其类型的零值,而指针也一样。一个新定义的或者没有任何指向的指针,有值 nil。在其他语言中,这经常被叫做空(NULL)指针,在 Go 中就是 nil 。让指针指向某些内容,可以使用取址操作符 ( & ),像这样:

package main 

import "fmt"

func main() {
    var p *int 
    fmt.Printf("%v\n",p) //← 打印 nil

    var i int //← 定义一个整形变量 i
    p = &i    //← 使得 p 指向 i, 获取 i 的地址
    fmt.Printf("%v\n",p) //打印内存地址

    *p = 6
    fmt.Printf("%v\n",*p) //打印6
    fmt.Printf("%v\n",i) //打印6

}

前面已经说了,没有指针运算,所以如果这样写: *p++ ,它表示 (*p)++ :首先获取指针指向的值,然后对这个值加一。这里注意与C语言的区别。

对于Go语言,严格意义上来讲,只有一种传递,也就是按值传递(by value)。当一个变量当作参数传递的时候,会创建一个变量的副本,然后传递给函数或者方法,你可以看到这个副本的地址和变量的地址是不一样的。

当变量当做指针被传递的时候,一个新的指针被创建,它指向变量指向的同样的内存地址,所以你可以将这个指针看成原始变量指针的副本。当这样理解的时候,我们就可以理解成Go总是创建一个副本按值转递,只不过这个副本有时候是变量的副本,有时候是变量指针的副本。


指针与普通变量区别

刚学习golang的人可能不是很明白普通变量和指针的区别,看到有人说其实普通变量是程序创造出来的,比如说 c 中

 a int 

那么在编译时 就会有 [a 地址 int] 这样来标识内存

普通变量a其实是语言本身创造了,是为了更方便的表示内存。我们对a进行访问其实就是直接对内存进行访问。至于a表示的内存的地址是多少,程序员一般不用关心。编译器会自动分配地址,也就是常说的为a分配一个地址。如果想知道a的地址也可以通过&a得知。

打个比方来理解:普通变量就像是房间(内存)外面的门牌号(总经理室),指针就是这个房间的地址(9#905)

变量是运行时系统给这个内存起的别名,内存地址是唯一的,程序中当我想拿到这个内存的值的时候,因为知道它的别名,所以直接用别名访问就可以得到值,又或者我能知道它唯一的地址我也能得到它的值,其实是两种不同的内存访问方式,但是变量是会变的,地址是不会变的。比如在go中

package main

func main(){
    a := 10   //此时有一块内存存放了10,它的地址由系统自动分配,别名是a
    a = 20   //内存存放的10变成了20
    var p *int
    p = &a   //或者直接写 p := &a
    //上面的p是一个指针,通过 *p 的方式同样可以访问 变量a指向 的内存

    /*当你动态申请内存的时候,指针的存在意义之一就被体现出来了*/ 
    ptr := new(int)   
    //申请了一块内存空间,没有办法指定别名,new()返回内存地址,用指针接收
    //此时并没有变量能直接指向这块内存,所以只能通过内存地址来访问
}

看到有个解释还可以,是说指针和普通变量区别的

1+2这个表达式永远得值3 
a+b这个表达式只依赖于a,b的值—–按名字访问称为直接访问 
*p + *q 这个表达式的值随着p,q指向的变量不同而不同—-按指针访问称为间接访问


指针的使用

方法中的指针
方法即为有接受者的函数,接受者可以是类型的实例变量或者是类型的实例指针变量。但两种效果不同。

1、类型的实例变量

func main(){
    person := Person{"TigerwolfC", 25}
    fmt.Printf("person<%s:%d>\n", person.name, person.age)
    person.sayHi()
    person.ModifyAge(28)
    person.sayHi()
}
type Person struct {
    name string
    age int
}
func (p Person) sayHi() {
    fmt.Printf("SayHi -- This is %s, my age is %d\n",p.name, p.age)
}
func (p Person) ModifyAge(age int) {
    fmt.Printf("ModifyAge")
    p.age = age
}

//输出结果

person<TigerwolfC:25>
SayHi -- This is TigerwolfC, my age is 25
ModifyAgeSayHi -- This is TigerwolfC, my age is 25

尽管 ModifyAge 方法修改了其age字段,可是方法里的p是person变量的一个副本,修改的只是副本的值。下一次调用sayHi方法的时候,还是person的副本,因此修改方法并不会生效。即实例变量的方式并不会改变接受者本身的值

2、类型的实例指针变量

package main

import "fmt"

func main(){
	person := Person{"TigerwolfC", 25}
	fmt.Printf("person<%s:%d>\n", person.name, person.age)
	person.sayHi()
	person.ModifyAge(28)
	person.sayHi()
}

type Person struct {
	name string
	age int
}

func (p *Person) sayHi() {
	fmt.Printf("SayHi -- This is %s, my age is %d\n",p.name, p.age)
}

func (p *Person) ModifyAge(age int) {
	fmt.Printf("ModifyAge")
	p.age = age
}

//输出结果

person<TigerwolfC:25>
SayHi -- This is TigerwolfC, my age is 25
ModifyAgeSayHi -- This is TigerwolfC, my age is 28

Go会根据Person的示例类型,转换成指针类型再拷贝,即 person.ModifyAge会变成 (&person).ModifyAge。

指针类型的接受者,如果实例对象是值,那么go会转换成指针,然后再拷贝,如果本身就是指针对象,那么就直接拷贝指针实例。因为指针都指向一处值,就能修改对象了。

3.如何选择 P 和 *P

在定义函数和方法的时候,需要对函数的参数和返回值定义成P*P深思熟虑,有些情况下可能还会有些困惑。
那么什么时候才应该把参数定义成类型P,什么情况下定义成类型*P呢。

一般的判断标准是看副本创建的成本和需求。

  1. 不想变量被修改。 如果你不想变量被函数和方法所修改,那么选择类型P。相反,如果想修改原始的变量,则选择*P
  2. 如果变量是一个大的struct或者数组,则副本的创建相对会影响性能,这个时候考虑使用*P,只创建新的指针,这个区别是巨大的
  3. (不针对函数参数,只针对本地变量/本地变量)对于函数作用域内的参数,如果定义成P,Go编译器尽量将对象分配到栈上,而*P很可能会分配到对象上,这对垃圾回收会有影响

4. 零值与nil(空指针)
变量声明而没有赋值,默认为零值,不同类型零值不同,例如字符串零值为空字符串;

指针声明而没有赋值,默认为nil,即该指针没有任何指向。当指针没有指向的时候,不能对(*point)进行操作包括读取,否则会报空指针异常。

func main(){
    // 声明一个指针变量 aPot 其类型也是 string
    var aPot *string
    fmt.Printf("aPot: %p %#v\n", &aPot, aPot) // 输出 aPot: 0xc42000c030 (*string)(nil)
    *aPot = "This is a Pointer"  // 报错: panic: runtime error: invalid memory address or nil pointer dereference
}

解决方法即给该指针分配一个指向,即初始化一个内存,并把该内存地址赋予指针变量,例如:// 声明一个指针变量 aPot 其类型也是 string
 

  var aPot *string
  fmt.Printf("aPot: %p %#v\n", &aPot, aPot) // 输出 aPot: 0xc42000c030 (*string)(nil)
  aPot = &aVar
  *aPot = "This is a Pointer"
  fmt.Printf("aVar: %p %#v \n", &aVar, aVar) // 输出 aVar: 0xc42000e240 "This is a Pointer"
  fmt.Printf("aPot: %p %#v %#v \n", &aPot, aPot, *aPot) // 输出 aPot: 0xc42000c030 (*string)(0xc42000e240) "This is a Pointer"

或者通过new开辟一个内存,并返回这个内存的地址。

var aNewPot *int
aNewPot = new(int)
*aNewPot = 666
fmt.Printf("aNewPot: %p %#v %#v \n", &aNewPot, aNewPot, *aNewPot) // 输出 aNewPot: 0xc42007a028 (*int)(0xc42006e1f0) 666

总结

  • Golang提供了指针用于操作数据内存,并通过引用来修改变量。
  • 只声明未赋值的变量,golang都会自动为其初始化为零值,基础数据类型的零值比较简单,引用类型和指针的零值都为nil,nil类型不能直接赋值,因此需要通过new开辟一个内存,或者通过make初始化数据类型,或者两者配合,然后才能赋值。
  • 指针也是一种类型,不同于一般类型,指针的值是地址,这个地址指向其他的内存,通过指针可以读取其所指向的地址所存储的值。
  • 函数方法的接受者,也可以是指针变量。无论普通接受者还是指针接受者都会被拷贝传入方法中,不同在于拷贝的指针,其指向的地方都一样,只是其自身的地址不一样。
     
### Golang指针结构体的使用 #### 定义结构体并创建实例 在 Go 语言中,可以通过 `struct` 关键字来定义自定义数据类型。下面展示了一个简单的员工结构体定义: ```go type Employee struct { id string name string } ``` 为了初始化该结构体,有两种方式:一种是通过值接收者的方式;另一种则是通过指针接收者的方式来操作。 #### 方法绑定到结构体上 对于结构体的方法定义,可以选择是否传递其指针作为接收者参数。如果希望修改原始结构体中的字段,则应采用指针形式[^1]。 ```go // 使用指针接收者的Set方法可以直接改变原结构体内存位置上的值 func (e *Employee) SetName(name string) { e.name = name } // 值接收者版本则会作用于副本而非实际对象本身 func (e Employee) SetValueReceiverExample(newID string){ e.id = newID // 这里只会影响拷贝后的临时变量id, 不影响原来的emp1.id } ``` #### 创建结构体实例及其内存模型理解 当声明一个新的结构体变量时,默认情况下它是按值传递的。这意味着每次将其赋给新变量或将其实例传入函数调用时都会复制整个结构体的内容。然而,在某些场景下这并不是期望的行为——特别是当我们想要多个地方共享同一份数据或者需要高效地处理大型结构体的时候。这时就引入了指针的概念[^2]。 考虑如下代码片段: ```go package main import ( "fmt" ) type Employee struct{ id string name string } func main(){ p1 := &Employee{id:"007",name:"Bond"} fmt.Printf("Before modification: %v\n",*p1) var p3 = p1 // 此处p3和p1都指向相同的堆分配区域 p3.name="New Name" fmt.Printf("After modifying via p3: Original pointer p1 -> %v\n",*p1) } ``` 上述例子展示了如何利用指针对相同的数据进行间接访问以及由此带来的副作用特性。一旦两个不同的名称(比如这里的 `p1`, `p3`) 绑定了同一个地址空间内的资源之后,任何一方对该资源所做的更改都将反映在整个程序范围内可见的地方。 另外值得注意的一点是在Go里面还可以很方便地实现结构体之间的嵌套关系,从而构建更加复杂的数据结构[^3]: ```go type Address struct { city, state string } type Person struct { name string age int address Address } var person = Person{} person.name = "kuangshen" person.age = 18 person.address = Address{city: "广州", state: "中国"} fmt.Println(person.name) fmt.Println(person.age) fmt.Println(person.address.city) ``` 这段代码说明了即使在一个较大的复合型态内部仍然能够轻松管理各个组成部分间的关联性而不必担心深浅拷贝等问题所带来的困扰。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值