指针（pointer）
文章发布较早，内容可能过时，阅读注意甄别。
# 1，指针。
指针是一个代表着某个内存地址的值。
这个内存地址往往是在内存中存住的两一个变量的值的起始位置。Go 语言对指针的支持介于 Java 语言和 C/C++语言之间，它既没有像 Java 语言那样取消了代码对指针的直接操作的能力，也避免了 C/C++语言中由于对指针的滥用而造成的安全和可靠性问题。
Go 语言虽然保留了指针，但与其他编程语言不同的是：
- 默认值 nil，没有 NULL 常量。
- 操作符"&"取变量地址，"*"通过指针访问目标对象。
- 不支持指针运算，不支持"->"运算符，直接用"."访问目标成员。
package main
import "fmt"
func main() {
var a int = 10
//每个变量有2层含义，变量的内存和变量的地址
fmt.Printf("a = %d\n", a) //a,变量的内存，也就是存在内存当中的内容
fmt.Printf("&a = %v\n", &a) //&a,变量的地址，也就是内存所在内存当中的位置，也叫指针
}
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
# 1，指针变量的基本使用。
package main
import "fmt"
func main() {
var a int = 10
//每个变量有2层含义，变量的内存和变量的地址
fmt.Printf("a = %d\n", a) //a,变量的内存，也就是存在内存当中的内容
fmt.Printf("&a = %v\n", &a) //&a,变量的地址，也就是内存所在内存当中的位置，也叫指针
//保存某个变量的地址，需要指针类型 *int 保存int的地址， **int则保存*int的地址
//定义一个变量p，类型为*int
var p *int
p = &a //指针变量指向谁，就把谁的地址赋给指针变量
fmt.Printf("p = %v, &a = %v\n", p, &a)
*p = 666 //*p操作的不是p的内存，是p所指向的内存(就是a)
fmt.Printf("*p = %v, a = %v\n", *p, a)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
以上是针对整形的一个测试，其实，在针对字符串的时候，也是一样的：
package main
import "fmt"
func main() {
s := "good bay"
var p *string = &s
*p = "ciao"
fmt.Printf("p = %v\n", p)
fmt.Printf("*p = %v\n", *p)
fmt.Printf("s = %v\n", s)
}
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
通过对 *p 赋另一个值来更改“对象”，这样 s 也会随之更改。
# 2，不要操作没有合法指向的内存。
package main
import "fmt"
func main() {
var p *int
fmt.Println("p = ", p)
//*p = 666 //err,因为p没有合法指向。
var a int
p = &a //p指向a的指针
*p = 666
fmt.Println("a = ", a)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
上边举了一个没有初始化值的变量，它会被缺省为 nil。
但是注意：还不能得到一个文字或常量的地址。
常量：
package main
import "fmt"
func main() {
const i = 5
fmt.Printf("&i = ", &i) //err: cannot take the address of i
}
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
文字：
package main
import "fmt"
func main() {
fmt.Printf("test = ", &10) //err: cannot take the address of 10
}
1
2
3
4
5
6
7
2
3
4
5
6
7
所以说，Go 语言和 C、C++ 以及 D 语言这些低级（系统）语言一样，都有指针的概念。但是对于经常导致 C 语言内存泄漏继而程序崩溃的指针运算（所谓的指针算法，如：pointer+2，移动指针指向字符串的字节数或数组的某个位置）是不被允许的。Go 语言中的指针保证了内存安全，更像是 Java、C# 和 VB.NET 中的引用。
因此 c = *p++ 在 Go 语言的代码中是不合法的。
# 2，new 函数。
函数 new(T)将创建一个 T 类型的匿名变量，所做的是为 T 类型的新值分配并清零一块儿内存空间，然后将这块内存空间的地址作为结果返回，而这个结果就是指向这个新的 T 类型值的指针值，返回的指针类型为*T。
# 1，new 函数的使用。
package main
import "fmt"
func main() {
/*之前的传统赋值方式
a := 10
var p *int
p = &a //指向一个合法内存
*p = 666
fmt.Println("*p =", *p)
*/
//p为*int类型，指向匿名int变量
var p *int
//new表示分配一个int类型的空间，给到变量p
p = new(int)
fmt.Println("*p =", *p) //*p=0
//同样，也可以使用自动推导类型进行赋值
q := new(int)
*q = 777
fmt.Println("*q =", *q)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
我们只需要使用 new()函数，无需担心其内存的生命周期或怎样将其删除，因为 Go 语言的内存管理系统会帮我们打理一切（相当于自动 GC）。
# 2，普通变量做函数的参数。
package main
import "fmt"
func swap(a, b int) {
a, b = b, a
fmt.Printf("swap : a= %d, b= %d\n", a, b)
}
func main() {
a, b := 10, 20
swap(a, b) //通过变量进行值的传递(站在变量的角度上)
fmt.Printf("main : a= %d, b= %d\n", a, b)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
# 3，指针做函数参数。
package main
import "fmt"
func swap(p1, p2 *int) {
*p1, *p2 = *p2, *p1
}
func main() {
a, b := 10, 20
//通过一个函数交换a和b的内容
swap(&a, &b) //地址传递
fmt.Printf("main : a= %d, b= %d\n", a, b)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
上次更新: 2024/07/04, 22:40:37
- 01
- 学习周刊-总第209期-2025年第18周05-03
- 02
- 学习周刊-总第208期-2025年第17周04-24
- 03
- Go开发实践之Gin框架将前端的dist目录embed到二进制04-22
|