一、 变量和内存地址
每个变量都有内存地址，可以说通过变量来操作对应大小的内存
注意：通过&符号可以获取变量的内存地址
通过下面例子来理解下：
实例1-1
package main import (
"fmt"
) func main() {
var a int32 =
fmt.Printf("%d\n", a)
fmt.Printf("%p\n", &a)
}
执行结果如下图所示：
二、 指针类型
2.1 定义
普通变量存储的是对应类型的值，这些类型就叫值类型；
指针类型的变量存储的是一个地址，所以又叫指针类型或引用类型；（任何类型都可以有指针类型，对于所有类型指针类型都生效）
32位操作系统内存占4字节，64位操作系统占8字节；
指针类型默认值为nil（空内存地址0x0）
a就是一个指针类型，存储的是内存地址，b是一个值类型，存储的是对应的值。
下面通过一个实例再来理解一下：
实例2-1
package main import (
"fmt"
) func main() {
var b int32 //b为值类型，存储的是对应的值
b =
var a *int32 //a为指针类型，存储的是内存地址
fmt.Printf("addr of a:%v\n", a) //指针a未赋值，其的默认值为nil，也就是空内存地址0x0
a = &b //a目前是一个指针，打印出来的也就是b（通过&取的内存地址）的内存地址
fmt.Printf("%v\n", a)
fmt.Printf("%v\n", *a) //*a表示取指针类型里指向的那块内存地址所对应的值
}
执行结果如下：
2.2 声明
指针类型定义， var 变量名 *类型
实例2-2
package main import (
"fmt"
) func main() {
var a *int
var b int = a = &b
fmt.Printf("value of a %v\n", a) //打印的是指针a的值
fmt.Printf("address of b %v\n", &b) //打印的是变量b的内存地址
fmt.Printf("address of a %v\n", &a) //打印指针a的内存地址 *a = //修改指针a存的内存地址所对应的值的值（其实就是修改b）
fmt.Printf("value of b %v\n", b) //打印变量b看是否修改成功
fmt.Printf("type of a %T\n", a) //%T能够打印变量的类型
}
执行结果如下：
2.3 指针初始化
2.3.1 方法1
var a *int = &b
再定义指针a之后，我们必须要为其初始化（不初始化，是一个空内存地址，程序会直接崩溃），也就是为其赋值，这里我们为指针a传入的是一个内存地址（也就分配了内存了），因为变量b在定义时已经为其分配了内存，这里是把变量b的内存地址赋值给了指针a；
2.3.2 方法2 new
var p *int = new(int)
变量p此时为指针，其指向的是一个类型为int的内存地址（底层new为其分配内存地址，做了初始化），然后就可以对指针p进行操作了
2.4 指针类型变量的默认值
指针类型变量的默认值为nil，也就是空地址0x0。所有操作都是有内存才能操作。
下面通过一个实例来验证下对一个空地址操作，程序就会崩溃：
实例2-3
package main import (
"fmt"
) func main() {
var a *int //只是定义了一个指针a
*a = //现在修改指针a，但指针a是空，必然会报错
fmt.Printf("%d\n", *a)
}
执行结果如下：
所以我们写程序一定要严谨，加上判断，可见如下例子：
实例2-4
package main import (
"fmt"
) func main() {
a :=
var b *int
if b == nil { //如果指针a是空地址，就为其赋值，不然程序会崩溃
fmt.Printf("b is %v\n", b)
b = &a
fmt.Printf("b after initialization is %v\n", b)
}
}
执行结果如下：
2.5 操作指针变量指向的地址里面的值
注意：通过* 符号可以获取指针变量指向的变量
*指针变量：就能够获得指针变量中存的内存地址对应的值。
如果想要修改指针变量的存的内存地址所对应的值？
方法：*指针变量 = 要修改的值
实例2-5
package main import (
"fmt"
) func main() {
b :=
a := &b
fmt.Println("address of b is", a)
fmt.Println("value of b is", *a) //获取指针变量中存的内存地址对应的值 *a = //修改指针变量的存的内存地址所对应的值
fmt.Println("address of b is", b)
}
执行结果如下图所示：
2.6 通过指针修改变量的值
如果想要修改指针变量的存的内存地址所对应的值？
方法：*指针变量 = 要修改的值
实例2-6
package main import (
"fmt"
) func main() {
b :=
a := &b
fmt.Println("address of b is", a)
fmt.Println("value of b is", *a)
*a++ //修改指针变量的存的内存地址所对应的值
fmt.Println("new value of b is", b)
}
执行结果如下：
2.7 指针变量传参
1、如果是一个值类型，通过函数是改不了他的值。
2、无论是指针类型还是值类型，函数传参都是会拷贝，只不过指针类型拷贝的是内存地址，无论指针类型的内存地址指向的那个值有多大，指针类型永远是拷贝8个字节（64位操作系统 int64 32位操作系统是4个字节 int32），所以说如果指针类型指向的那块内存地址存的值很大的话，指针传值性能更高。
下面通过这个例子来详细解释下：
实例2-7 实例1
package main import (
"fmt"
) func modify(a int) {
fmt.Printf("2. address of a=%p, value of a:%v\n", &a, a)
a =
} func modify2(a *int) {
fmt.Printf("4. address of a:%v, value of a :%v\n", &a, a)
*a =
} func main() {
var b int =
fmt.Printf("1. address of b=%p, value of b:%v\n", &b, b)
modify(b) var p *int = &b
fmt.Printf("3. address of p:%v, value of p:%v\n", &p, p) modify2(p)
fmt.Printf("b=%d\n", b)
}
执行结果如下：
解释：
1、函数传参是值的拷贝，只不过值类型传递的是值，指针类型（引用类型）传递的是内存地址。
2、定义b为100，当首先执行modify函数时，传递的是b的副本，所以无论函数中怎么修改，是不影响变量b值本身的。在经过modify2函数执行后，虽然传递的也是副本，但是传递的是b的内存地址，而函数又是基于该内存地址进行修改的，所以值由100修改为了1000
实例2-8 实例2
package main import (
"fmt"
) func change(val *int) {
*val = //修改指针多存的内存地址对应的值
}
func main() {
a :=
fmt.Println("value of a before function call is", a)
b := &a //传入a的内存地址
change(b)
fmt.Println("value of a after function call is", a)
}
执行结果如下：
实例2-9 实例3
package main import (
"fmt"
) func modify(arr *[]int) {
(*arr)[] =
}
func main() {
a := []int{, , }
modify(&a) //传递的是内存地址所以可以修改
fmt.Println(a)
}
执行结果如下：
2.8 切片传参
实例2-10
package main import (
"fmt"
) func modify(sls []int) {
sls[] =
}
func main() {
a := []int{, , }
modify(a[:]) //切片是引用类型，所以底层也是指针，所以是可以修改的，修改是生效的
fmt.Println(a)
}
执行结果如下：
三、 make和new的区别
1、make用来分配引用类型的内存，比如 map、 slice以及channel，make除了分配内存外，还为这些复杂的数据类型（底层结构复杂，有很多字段在里面）做初始化
2、new用来分配除引用类型的所有其他类型的内存，比如 int、数组等，其实new可以为任何类型的分配内存，只不过针对引用类型（切片、map）来说，new虽然可以为其分配内存，但是其还是需要借助make去初始化。
通过下面这个实例深入理解：
实例3-1
package main import (
"fmt"
) type User struct {
Name string
age int
} func test1() {
var p *int = new(int)
*p =
fmt.Printf("p:%v address:%v\n", *p, p) var pUser *User = new(User)
(*pUser).age =
pUser.Name = "user01" //正常来说规范写应该是(*pUser).Name，但是go语言针对结构体这里做了优化（切片、map不可以，依然需要规范写），可以简化写。 fmt.Printf("user:%v\n", *pUser)
} func test2() {
var p *[]int = new([]int) //new为切片分配内存
*p = make([]int, ) //切片需要make为其初始化才能使用 (*p)[] =
(*p)[] = fmt.Printf("p:%#v\n", *p) var p1 *map[string]int = new(map[string]int) //new为map分配内存
*p1 = make(map[string]int, ) //map需要make为其初始化才可以使用
(*p1)["key"] =
(*p1)["key2"] = fmt.Printf("p:%#v\n", *p1)
} func main() {
test1()
test2()
}
执行结果如下：
四、 值拷贝和引用拷贝
4.1 值拷贝
值类型拷贝，相当于完全拷贝一份（有副本存在），当对副本进行修改时，无论如何是不影响变量本身的。
实例4-1
package main import (
"fmt"
) func main() {
var a int =
fmt.Printf("a addr is %p\n", &a)
b := a
fmt.Printf("b addr is %p\n", &b)
a =
fmt.Printf("a addr is %p\n", &a)
fmt.Printf("a=%d b=%d", a, b)
}
执行结果如下：
解释：
正如此题，a赋值给b，其做的就是一个值拷贝，b就相当于是拷贝的这个副本，无论b如何变化，是不影响a本身的，本身他们就是2块独立的内存地址。所以a的值在变化后，b是不受影响的。
4.2 引用拷贝
引用拷贝，拷贝的是内存地址，所以当其中一个变量修改了，另一个变量也会修改，因为他们对应的是同一个内存地址。
通过如下例子再来理解一下：
实例4-2
package main import (
"fmt"
) func main() {
var a int =
var b *int = &a
var c *int = b
*c =
fmt.Printf("a=%v b=%v c=%v", a, *b, *c)
}
执行结果如下：
解释:
我们可以发现a、b和c都是同事指向同一内存地址，一旦对任何一个变量修改，另外两个变量也会修改。