缘起
不管使用什么语言，日常生活中能常在技术群中看到类似这样的问题（当然这个图
是我瞎编的，真实的讨论会比图中 peace 一些~）：
本人在这个话题上被别人鄙视过，这次写一篇文章，好好研究一下这个话题~ 这张图的问题是： T类型在函数调用中是引用传递还是值传递。想要弄清这个问题，需要明确什么是引用，什么是值，所以本文会先讨论一下 T类型的数据类型是值类型还是引用类型。另外，文章只针对Golang这门语言进行探索。 那么，什么是值类型，引用传递又是怎么回事呢？下面就跟小编一起来了解一下吧（~:
验证
数据类型
关于值类型、引用类型，维基百科中这样定义：
定义中把数据类型分为值类型和引用类型两类，然后介绍 值类型的值是信息本身；引用类型来的值是引用，这个引用可以为 nil，也可以是一个引用值，用户可以根据引用值找到信息本身。
举个例子，现在有个变量要去存不同类型的值。对于一些占用空间比较小的类型，比如 整数、浮点数和bool类型，变量存的是这些值本身；而对于一些占用空间较大的类型，变量存的是类型的指针，用户可以根据指针找到这个值，这样的好处之一是可以节省内存。注意对于引用类型，如果两个变量都保存某个值的引用，一个变量通过引用把信息改变后，用户可以通过另一个变量看到信息的变化。
为啥会有引用类型呢，如果需要在多个过程中针对某个数据进行计算，那就得用地址作为信息去传递。达到的效果是 两个变量都保存某个值的引用，一个变量通过引用把信息改变后，用户通过另一个变量看到改变后的信息。这样做还有个好处是可以节省空间，因为你可以使用指针来代替一个占用空间很大的结构体的传递。
简单通过图片看一下这两种分类的区别：
值类型（Golang代码）
引用类型（C++代码）
&#include <stdio.h>
int main() {
int a = 10;
int &b = a; // 定义了一个引用变量b去引用a的值, 下同
int &c = b;
printf("%d %d %d\n", a, b, c);
printf("%p %p %p\n", &a, &b, &c);
a = 100;
printf("%d %d %d\n", a, b, c);
return 0;
}这段代码的运行结果为
~ g++ main.cpp -o fk1 && ./fk1
10 10 10
0x7ffee11148c8 0x7ffee11148c8 0x7ffee11148c8
100 100 100
&Tint
package main
import "fmt"
func main() {
a := 10086
var b, c = &a, &a // b、c变量存的都是a的地址
fmt.Println(b, c) // b、c变量保存的地址相同
fmt.Println(&b, &c) // b、c变量本身的值不相同
d := 100
b = &d // b改变，a c的值不变
fmt.Println(a, *b, *c)
}输出结果:
0xc00001a0b0 0xc00001a0b0
0xc00000e028 0xc00000e030
10086 100 10086
在这段代码中，b和c都保存了a的地址，但是b、c本身是独立的，改变b的值不会对a、c产生影响。所以可以把Golang中的int类型归为值类型之内。
make函数为啥能初始化map、slice、chan这三种不同的数据类型go tool compilepackage main
func main() {
var a = 10086
b := &a
print(b, ",", *b)
} go tool compile -S -N -l main.go go tool compile-S-N-l➜ fk git:(master) ✗ go tool compile -S -N -l main.go
"".main STEXT size=143 args=0x0 locals=0x30
------------------------------------------------调度相关代码 头部 start ------------------------------------------------
// 00000~00013主要作用: 检查是否函数栈帧够用，不够用跳到尾部进行扩容
0x0000 00000 (main.go:3) TEXT "".main(SB), ABIInternal, $48-0 // 声明main函数, $48-0中：$48代表函数栈空间大小是48字节 ，0代表函数没有参数和返回值
0x0000 00000 (main.go:3) MOVQ (TLS), CX // 把当前g的地址赋给CX寄存器
0x0009 00009 (main.go:3) CMPQ SP, 16(CX) // 16(CX)对应g.stackguard0, 与SP寄存器进行比较
0x000d 00013 (main.go:3) JLS 133 // 如果SP寄存器小于stackguard0，跳转到133这个位置 //00013代表位置
------------------------------------------------调度相关代码 头部 end ------------------------------------------------
0x000f 00015 (main.go:3) SUBQ $48, SP // SP-48 使其指向栈顶位置,这行命令是为了设置stack frame空间, 让SP指向栈顶位置
0x0013 00019 (main.go:3) MOVQ BP, 40(SP) // *(SP+40) = BP
0x0018 00024 (main.go:3) LEAQ 40(SP), BP // 把*(SP+40) 的地址赋值给BP寄存器, 使BP寄存器指向当前函数栈帧的栈底位置
0x001d 00029 (main.go:3) FUNCDATA $0, gclocals·69c1753bd5f81501d95132d08af04464(SB) // FUNCDATA 和 PCDATA均是gc使用，可忽略，后以...代替
0x001d 00029 (main.go:3) FUNCDATA $1, gclocals·9fb7f0986f647f17cb53dda1484e0f7a(SB)
0x001d 00029 (main.go:3) FUNCDATA $2, gclocals·9fb7f0986f647f17cb53dda1484e0f7a(SB)
0x001d 00029 (main.go:4) PCDATA $0, $0 // FUNCDATA 和 PCDATA均是gc使用，忽略
0x001d 00029 (main.go:4) PCDATA $1, $0
0x001d 00029 (main.go:4) MOVQ $10086, "".a+16(SP) // a = 10086
0x0026 00038 (main.go:5) PCDATA $0, $1
0x0026 00038 (main.go:5) LEAQ "".a+16(SP), AX // 把 a变量的地址 赋给AX寄存器
0x002b 00043 (main.go:5) PCDATA $1, $1
0x002b 00043 (main.go:5) MOVQ AX, "".b+32(SP) // 把 AX寄存器的值 赋给b变量
0x0030 00048 (main.go:7) PCDATA $0, $0
0x0030 00048 (main.go:7) TESTB AL, (AX)
0x0032 00050 (main.go:7) MOVQ "".a+16(SP), AX
0x0037 00055 (main.go:7) MOVQ AX, ""..autotmp_2+24(SP)
0x003c 00060 (main.go:7) CALL runtime.printlock(SB)
0x0041 00065 (main.go:7) PCDATA $0, $1
0x0041 00065 (main.go:7) PCDATA $1, $0
0x0041 00065 (main.go:7) MOVQ "".b+32(SP), AX
0x0046 00070 (main.go:7) PCDATA $0, $0
0x0046 00070 (main.go:7) MOVQ AX, (SP)
0x004a 00074 (main.go:7) CALL runtime.printpointer(SB)
0x004f 00079 (main.go:7) PCDATA $0, $1
0x004f 00079 (main.go:7) LEAQ go.string.","(SB), AX
0x0056 00086 (main.go:7) PCDATA $0, $0
0x0056 00086 (main.go:7) MOVQ AX, (SP)
0x005a 00090 (main.go:7) MOVQ $1, 8(SP)
0x0063 00099 (main.go:7) CALL runtime.printstring(SB)
0x0068 00104 (main.go:7) MOVQ ""..autotmp_2+24(SP), AX
0x006d 00109 (main.go:7) MOVQ AX, (SP)
0x0071 00113 (main.go:7) CALL runtime.printint(SB)
0x0076 00118 (main.go:7) CALL runtime.printunlock(SB)
0x007b 00123 (main.go:8) MOVQ 40(SP), BP
0x0080 00128 (main.go:8) ADDQ $48, SP
0x0084 00132 (main.go:8) RET
0x0085 00133 (main.go:8) NOP
------------------------------------------------调度相关代码 尾部 start ------------------------------------------------
// 00133 主要作用:1.栈扩容；2.被runtime管理调度
0x0085 00133 (main.go:3) PCDATA $1, $-1 // FUNCDATA 和 PCDATA均是gc使用，忽略
0x0085 00133 (main.go:3) PCDATA $0, $-1 // FUNCDATA 和 PCDATA均是gc使用，忽略
0x0085 00133 (main.go:3) CALL runtime.morestack_noctxt(SB) // morestack but not preserving ctxt. 执行栈空间扩容
0x008a 00138 (main.go:3) JMP 0
------------------------------------------------调度相关代码 尾部 end ------------------------------------------------通过汇编我们可以看到b变量保存的是a变量的地址，这个过程是用AX寄存器实现的(附录部分会介绍Plan9指令，理解有问题的同学可以先看附录)。
string
让我们接着看一下string这种数据结构底层做了啥：
package main
func main() {
var a = "hello"
b := &a
c := "world"
b = &c
println(*b, b) // world 0xc000044730
println(a, &a) // hello 0xc000044740
}汇编分析(只要分析main.go:4和main.go:5)：
➜ fk git:(master) ✗ go tool compile -S -N -l main.go | grep -v PCDATA
0x0021 00033 (main.go:4) LEAQ go.string."hello"(SB), AX // AX 取hello这个.rodata段数据的地址
0x0028 00040 (main.go:4) MOVQ AX, "".a+24(SP) // 把AX 赋给a变量 位置:SP+24byte
0x002d 00045 (main.go:4) MOVQ $5, "".a+32(SP) // 把5(字符串长度)赋给a变量 位置:SP+32byte
0x0036 00054 (main.go:5) LEAQ "".a+24(SP), AX // AX取 "".a+24(SP) 的地址
0x003b 00059 (main.go:5) MOVQ AX, "".b+16(SP) // 把AX的值赋给b变量b:=&aruntime.string.go type stringStruct struct {
str unsafe.Pointer
len int
}把代码稍微改一下：
package main
func main() {
var a = "hello"
b := a
println(a, ",", b) // hello , hello
println(&a, ",", &b) // 0xc000044740 , 0xc000044730
}汇编分析
➜ fk git:(master) ✗ go tool compile -S -N -l main.go
0x0021 00033 (main.go:4) LEAQ go.string."hello"(SB), AX // AX 取hello这个.rodata段数据的地址
0x0028 00040 (main.go:4) MOVQ AX, "".a+48(SP) // AX 赋值给a 位置: sp+48byte
0x002d 00045 (main.go:4) MOVQ $5, "".a+56(SP) // 长度5赋值给a 位置: sp+56byte
0x0036 00054 (main.go:5) MOVQ AX, "".b+32(SP) // AX 赋值给b 位置: sp+32byte
0x003b 00059 (main.go:5) MOVQ $5, "".b+40(SP) // 长度5赋值给b 位置: sp+40byteb := ab = &cslice
代码：
package main
import "fmt"
func main() {
a := make([]int, 10)
a[0] = 1
b := a
fmt.Println(a, b)
}汇编：
0x002f 00047 (main.go:6) LEAQ type.int(SB), AX // 把type.int值的指针赋给AX
0x0036 00054 (main.go:6) MOVQ AX, (SP) // 把寄存器里的值赋给sp
0x003a 00058 (main.go:6) MOVQ $10, 8(SP) // 把len的值赋给sp+8的位置
0x0043 00067 (main.go:6) MOVQ $10, 16(SP) // 把cap的值赋给sp+16的位置 (以上这几行都是为了给makeslice准备参数)
0x004c 00076 (main.go:6) CALL runtime.makeslice(SB) // 调用makeslice
0x0051 00081 (main.go:6) MOVQ 24(SP), AX // AX = *(sp+24) 把makeslice的结果赋给AX
0x0056 00086 (main.go:6) MOVQ AX, "".a+96(SP) // AX 赋给变量a 位置:sp + 96byte
0x005b 00091 (main.go:6) MOVQ $10, "".a+104(SP) // len 10 赋给变量a 位置:sp + 104byte
0x0064 00100 (main.go:6) MOVQ $10, "".a+112(SP) // cap 10 赋给变量a 位置:sp + 112byte
0x006d 00109 (main.go:7) JMP 111 // 这行感觉没啥卵用
0x006f 00111 (main.go:7) MOVQ $1, (AX) // a[0] = 1
0x0076 00118 (main.go:9) MOVQ "".a+104(SP), AX // 把len赋给AX
0x007b 00123 (main.go:9) MOVQ "".a+96(SP), CX // 把指针赋给CX
0x0080 00128 (main.go:9) MOVQ "".a+112(SP), DX // 把cap赋给DX
0x0085 00133 (main.go:9) MOVQ CX, "".b+72(SP) // CX赋给b
0x008a 00138 (main.go:9) MOVQ AX, "".b+80(SP) // AX赋给b
0x008f 00143 (main.go:9) MOVQ DX, "".b+88(SP) // DX赋给bfunc makeslice(et *_type, len, cap int) unsafe.Pointerb := atype slice struct {
array unsafe.Pointer
len int
cap int
}这样的表现让slice这种数据类型似乎属于引用类型这个种类，在Go语言的官方文档有段声明map的定义中能找到类似的描述:
mnil遗憾的是，slice在某些场合的表现并不属于引用类型：
package main
func fk(a []int) {
a = make([]int, 0)
println(a == nil) // false
}
func main() {
var a []int
println(a == nil) // true
fk(a)
println(a == nil) // true
}实际上，早在13年，Go语言之父之一就在go spec中声明:
spec: Go has no 'reference types'
reference todescriptor forSlices, maps and channels are reference types
map
代码：
package main
import "fmt"
func main() {
a := make(map[string]int)
b := a
fmt.Println(a, b)
}汇编(非相关汇编代码已删去)：
$ go tool compile -S -N -l func-param.go
0x002f 00047 (main.go:6) CALL runtime.makemap_small(SB) // 调用 makemap_small 函数
0x0034 00052 (main.go:6) MOVQ (SP), AX // AX = *(BP)
0x0038 00056 (main.go:6) MOVQ AX, "".a+56(SP) // 把 AX 赋给a变量
0x003d 00061 (main.go:7) MOVQ AX, "".b+48(SP) // 把 AX 赋给b变量func makemap_small() *hmaphmap这让它看起来像是引用类型，但是它同样有非引用类型的表现：
package main
func fk(m map[string]int) {
m = make(map[string]int)
println(m == nil) // false
}
func main() {
var a map[string]int
println(a == nil) // true
fk(a)
println(a == nil) // true
}channel
代码
package main
func main() {
a := make(chan int)
b := a
println(a, b)
}汇编：
0x001d 00029 (main.go:4) LEAQ type.chan int(SB), AX // 把type.chan int值的指针赋给AX
0x0024 00036 (main.go:4) MOVQ AX, (SP) // *(SP) = AX
0x0028 00040 (main.go:4) MOVQ $0, 8(SP) // *(SP+8) = 0
0x0031 00049 (main.go:4) CALL runtime.makechan(SB) // 调用runtime.makechan
0x0036 00054 (main.go:4) MOVQ 16(SP), AX // AX = *(SP+16) 即把makechan的结果赋给AX寄存器
0x003b 00059 (main.go:4) MOVQ AX, "".a+32(SP) // a = AX
0x0040 00064 (main.go:5) MOVQ AX, "".b+24(SP) // b = AXfunc makechan(t *chantype, size int) *hchanstruct
代码：
package main
import "fmt"
type F struct {
A int
}
func main() {
a := F{A: 1}
b := a
b.A = 2
fmt.Println(a, b) // {1} {2}
}汇编：
0x002f 00047 (main.go:10) MOVQ $0, "".a+56(SP) // 这行估计是为了初始化a
0x0038 00056 (main.go:10) MOVQ $1, "".a+56(SP) // 把 1 赋值给a
0x0041 00065 (main.go:11) MOVQ $1, "".b+48(SP) // 把 1 赋值给b
0x004a 00074 (main.go:13) MOVQ $2, "".b+48(SP) // b的值修改为2结构体这种数据类型没什么争议，不管在什么层面上都更像值类型。
小结
经过上面对各种数据类型在运行时地址、源码以及汇编层面的表现，并结合Go官方文档，有的读者可能还是有点懵逼，我觉得这是正常的。即使Go语言之父之一的大佬13年举大旗明确说明Go中没有引用类型，但是在18年的文档中还是反水说xx type is reference type 。这篇文档也许是其他人写的，侧面说明这个概念确实是confused~
函数调用
同样先来看看定义：
By definition, pass by value means you are making a copy in memory of the actual parameter's value that is passed in, a copy of the contents of the actual parameter. ... In pass by reference (also called pass by address), a copy of the address of the actual parameter is stored.
中文意思是：
值传递会在内存中拷贝一份实参的值，值是指实参的内容。引用传递会拷贝一份实参的地址。
通过图片看一下两种调用的区别：
值传递(Go代码)：
引用传递(c++)：
通过c++代码看一下引用传递的实际表现：
#include <stdio.h>
void fk(int & count)// & 使其进行引用传递
{
count=count+1;
printf("fk: %p, %d\n",&count, count); // 把各种变量信息打印出来
}
int main()
{
int count=0; //
printf("before call fk: %p, %d\n",&count, count); //调用函数前看一下各个变量信息
fk(count);
printf("after call fk: %p, %d\n",&count, count); //调用函数后看一下各个变量信息
return 0;
}输出结果：
$ g++ main.cpp -o fk1 && ./fk1
before call fk: 0x7ffee90b57f8, 0
fk: 0x7ffee90b57f8, 1
after call fk: 0x7ffee90b57f8, 1
Go语言中是没有引用传递的，官方文档中Q&A部分对函数调用中参数传递早有定义：
intint大概翻译一下： Golang中函数传递都是值传递，也就是说函数总是获得传入参数的副本，就如同一个赋值语句讲值分配给参数一样。举例来说：在函数里传入一个 int 类型时会拷贝一个 int 类型的副本，传入一个指针将会拷贝一份指针副本，但并不会拷贝指针指向的值。
经过前面的分析，相信读者对一些基本数据类型已经有一定的想法。让我们看一下答案中专门强调的指针类型在函数传参中的表现：
package main
import "fmt"
func fk(a *int) {
fmt.Printf("func a'value: %p\n", a) // func a'value: 0xc00001a0a0
fmt.Printf("func a'address: %p\n", &a) // func a'address: 0xc00000e030 // 指针指向的值一样，但是会copy一个新的指针
}
func main() {
a := 10086
fmt.Printf("main a'adreess: %p\n", &a) // main a'adreess: 0xc00001a0a0
fk(&a)
}指针类型作为函数参数在传递时会拷贝一份新的指针，只不过两份指针指向同一个值。从结果来看符合值传递的概念。
总结
以一些词汇对事物做分类的目的是要降低用户的理解成本，但是 引用类型和值类型 对变量分类， 引用传递和值传递 对函数调用分类，不仅没有降低成本，反而让人更困惑了。所以个人认为对于数据类型、函数调用这部分知识理解底层原理即可，不要为几个概念来回撕逼了。