# 1.7 数据类型:指针
## 0. 什么是指针
当我们定义一个变量 name
```go
var name string = "Go编程时光"
```
此时,name 是变量名,它只是编程语言中方便程序员编写和理解代码的一个标签。
当我们访问这个标签时,机算机会返回给我们它指向的内存地址里存储的值:`Go编程时光`。
出于某些需要,我们会将这个内存地址赋值给另一个变量名,通常叫做 ptr(pointer的简写),而这个变量,我们称之为指针变量。
换句话说,指针变量(一个标签)的值是指针,也就是内存地址。
根据变量指向的值,是否是内存地址,我把变量分为两种:
- 普通变量:存数据值本身
- 指针变量:存值的内存地址
## 1. 指针的创建
指针创建有三种方法
**第一种方法**
先定义对应的变量,再通过变量取得内存地址,创建指针
```go
// 定义普通变量
aint := 1
// 定义指针变量
ptr := &aint
```
**第二种方法**
先创建指针,分配好内存后,再给指针指向的内存地址写入对应的值。
```go
// 创建指针
astr := new(string)
// 给指针赋值
*astr = "Go编程时光"
```
**第三种方法**
先声明一个指针变量,再从其他变量取得内存地址赋值给它
```go
aint := 1
var bint *int // 声明一个指针
bint = &aint // 初始化
```
上面的三段代码中,指针的操作都离不开这两个符号:
- `&` :从一个普通变量中取得内存地址
- `*`:当`*`在赋值操作符(=)的右边,是从一个指针变量中取得变量值,当`*`在赋值操作符(=)的左边,是指该指针指向的变量
通过下面这段代码,你可以熟悉这两个符号的用法
```go
package main
import "fmt"
func main() {
aint := 1 // 定义普通变量
ptr := &aint // 定义指针变量
fmt.Println("普通变量存储的是:", aint)
fmt.Println("普通变量存储的是:", *ptr)
fmt.Println("指针变量存储的是:", &aint)
fmt.Println("指针变量存储的是:", ptr)
}
```
输出如下
```
普通变量存储的是: 1
普通变量存储的是: 1
指针变量存储的是: 0xc0000100a0
指针变量存储的是: 0xc0000100a0
```
要想打印指针指向的内存地址,方法有两种
```go
// 第一种
fmt.Printf("%p", ptr)
// 第二种
fmt.Println(ptr)
```
## 2. 指针的类型
我们知道字符串的类型是 string,整型是int,那么指针如何表示呢?
写段代码试验一下就知道了
```go
package main
import "fmt"
func main() {
astr := "hello"
aint := 1
abool := false
arune := 'a'
afloat := 1.2
fmt.Printf("astr 指针类型是:%T\n", &astr)
fmt.Printf("aint 指针类型是:%T\n", &aint)
fmt.Printf("abool 指针类型是:%T\n", &abool)
fmt.Printf("arune 指针类型是:%T\n", &arune)
fmt.Printf("afloat 指针类型是:%T\n", &afloat)
}
```
输出如下,可以发现用 `*`+所指向变量值的数据类型,就是对应的指针类型。
```
astr 指针类型是:*string
aint 指针类型是:*int
abool 指针类型是:*bool
arune 指针类型是:*int32
afloat 指针类型是:*float64
```
所以若我们定义一个只接收指针类型的参数的函数,可以这么写
```
func mytest(ptr *int) {
fmt.Println(*ptr)
}
```
## 3. 指针的零值
当指针声明后,没有进行初始化,其零值是 nil。
```go
func main() {
a := 25
var b *int // 声明一个指针
if b == nil {
fmt.Println(b)
b = &a // 初始化:将a的内存地址给b
fmt.Println(b)
}
}
```
输出如下
```
<nil>
0xc0000100a0
```
## 4. 指针与切片
切片与指针一样,都是引用类型。
如果我们想通过一个函数改变一个数组的值,有两种方法
1. 将这个数组的切片做为参数传给函数
2. 将这个数组的指针做为参数传给函数
尽管二者都可以实现我们的目的,但是按照 Go 语言的使用习惯,建议使用第一种方法,因为第一种方法,写出来的代码会更加简洁,易读。具体你可以参数下面两种方法的代码实现
**使用切片**
```go
func modify(sls []int) {
sls[0] = 90
}
func main() {
a := [3]int{89, 90, 91}
modify(a[:])
fmt.Println(a)
}
```
**使用指针**
```go
func modify(arr *[3]int) {
(*arr)[0] = 90
}
func main() {
a := [3]int{89, 90, 91}
modify(&a)
fmt.Println(a)
}
```
---
- 第一章:基础知识
- 1.1 一文搞定开发环境的搭建
- 1.2 五种变量创建的方法
- 1.3 数据类型:整型与浮点型
- 1.4 数据类型:byte、rune与字符串
- 1.5 数据类型:数组与切片
- 1.6 数据类型:字典与布尔类型
- 1.7 数据类型:指针
- 1.8 流程控制:if-else
- 1.9 流程控制:switch-case
- 1.10 流程控制:for 循环
- 1.11 流程控制:goto 无条件跳转
- 1.12 流程控制:defer 延迟语句
- 1.13 流程控制:理解 select 用法
- 1.14 异常机制:panic 和 recover
- 1.15 语法规则:理解语句块与作用域
- 第二章:面向对象
- 2.1 面向对象:结构体与继承
- 2.2 面向对象:接口与多态
- 2.3 面向对象:结构体里的 Tag 用法
- 2.4 学习接口:详解类型断言
- 2.5 学习接口:Go 语言中的空接口
- 2.6 学习接口:接口的三个"潜规则"
- 2.7 学习反射:反射三定律
- 2.8 学习反射:全面学习反射的函数
- 2.9 详细图解:静态类型与动态类型
- 2.10 关键字:make 和 new 的区别?
- 第三章:项目管理
- 3.1 依赖管理:包导入很重要的 8 个知识点
- 3.2 依赖管理:超详细解读 Go Modules 应用
- 3.3 开源发布:如何开源自己写的包给别人用?
- 3.4 代码规范:Go语言中编码规范
- 第四章:并发编程
- 4.1 学习 Go 函数:理解 Go 里的函数
- 4.2 学习 Go 协程:goroutine
- 4.3 学习 Go 协程:详解信道/通道
- 4.4 学习 Go 协程:WaitGroup
- 4.5 学习 Go 协程:互斥锁和读写锁
- 4.7 学习 Go 协程: 信道死锁经典错误案例
- 4.7 学习 Go 协程:如何实现一个协程池?
- 4.8 理解 Go 语言中的 Context
- 4.9 学习一些常见的并发模型
- 第五章:学标准库
- 5.1 fmt.Printf 方法详解
- 5.2 os/exec 执行命令的五种姿势
- 第六章:开发技能
- 6.1 Go 命令:go test 工具详解
- 6.2 单元测试:如何进行单元测试?
- 6.3 调试技巧:使用 GDB 调试 Go 程序
- 6.4 Go 命令: Go 命令指南
- 第七章:暂未分类
- 7.1 20 个学习 Go 语言的精品网站
