一文搞懂参数传递原理

前言

最近一年多的时间陆续接触了一些对我来讲陌生的语言，主要就是 Python 和 Go，期间为了快速实现需求只是依葫芦画瓢的撸代码；并无深究一些细节与原理。

就拿参数传递一事来讲各个语言的实现细节各不相同，但又有相似之处；在许多新手入门时容易搞不清楚，致使犯一些低级错误。

Java

基本类型传递

先拿我最熟悉的 Java 来讲，我相信应该没人会写这样的代码：

@Test
    public void testBasic() {
        int a = 10;
        modifyBasic(a);
        System.out.println(String.format("最终结果 main a==%s", a));
    }

    private void modifyBasic(int aa) {
        System.out.println(String.format("修改以前 aa==%s", aa));
        aa = 20;
        System.out.println(String.format("修改以后 aa==%s", aa));
    }

输出结果:

修改以前 aa==10
修改以后 aa==20
最终结果 main a==10

不过从这段代码的目的来看应该是想要修改 a 的值，从直觉上来讲若是修改为功也是能理解的。

至于结果与预期不符合的根本缘由是理解错了参数的值传递与引用传递。

---

在这以前仍是先明确下值传递与引用传递的区别：

这里我们先抛出结论，Java 采用的是值传递；这样也能解释为何上文的例子没有成功修改原始数据。

参考下图更好理解：

当发生函数调用的时候 a 将本身传入到 modifyBasic 方法中，同时将本身的值复制了一份并赋值给了一个新变量 aa 从图中能够看出这是 a 和 aa 两个变量没有一毛钱关系，因此对 aa 的修改并不会影响到 a。

有点相似于我把苹果给了老婆，她把苹果削好了；但我手里这颗并无变化，由于她只是从餐盘里拿了一颗如出一辙的苹果削好了。

若是我想要她那颗，只能让她把削好的苹果给我；也就相似于使用方法的返回值。

a = modifyBasic(a);

引用类型传递

下面来看看引用类型的传递：

private class Car{
        private String name;

        public Car(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "Car{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

		@Test
    public void test01(){
        Car car1 = new Car("benz");
        modifyCar1(car1);
        System.out.println(String.format("最终结果 main car1==%s", car1));
    }

    private void modifyCar1(Car car){
        System.out.println(String.format("修改以前 car==%s", car));
        car.name = "bwm";
        System.out.println(String.format("修改以后 car==%s", car));
    }

在这个例子里先建立了一个 benz 的 car1，经过一个方法修改成 bmw 那最开始的 car1 会受到影响嘛？

修改以前 car==Car{name='benz'}
修改以后 car==Car{name='bwm'}
最终结果 main car1==Car{name='bwm'}

结果可能会与部分人预期相反，这样的修改倒是能够影响到原有数据的？这岂不是和值传递不符，看样子这是引用传递吧？

别急，经过下图分析后你们就能明白：

在 test01 方法中咱们建立了一个 car1 的对象，该对象存放于堆内存中，假设内存地址为 0x1102 ，因而 car1 这个变量便应用了这块内存地址。

当咱们调用 modifyCar1 这个方法的时候会在该方法栈中建立一个变量 car ,接下来重点到了：

这个 car 变量是由本来的入参 car1 复制而来，因此它所对应的堆内存依然是 0x1102；

因此当咱们经过 car 这个变量修改了数据后，本质上修改的是同一块堆内存中的数据。从而本来引用了这块内存地址的 car1 也能查看到对应的变化。

这里理解起来可能会比较绕，但咱们记住一点就行：

传递引用类型的数据时，传递的并非引用自己，依然是值；只是这个值 是内存地址罢了。

由于把相同的内存地址传过去了，因此对数据的操做依然会影响到外部。

因此同理，相似于这样的代码也会影响到外部原始数据：

@Test
    public void testList(){
        List<Integer> list = new ArrayList<>();
        list.add(1);
        addList(list);
        System.out.println(list);
    }

    private void addList(List<Integer> list) {
        list.add(2);
    }

    [1, 2]

---

那若是是这样的代码：

@Test
    public void test02(){
        Car car1 = new Car("benz");
        modifyCar(car1);
        System.out.println(String.format("最终结果 main car1==%s", car1));
    }

    private void modifyCar(Car car2) {
        System.out.println(String.format("修改以前 car2==%s", car2));
        car2 = new Car("bmw");
        System.out.println(String.format("修改以后 car2==%s", car2));
    }

假设 Java 是引用传递那最终的结果应该是打印 bmw 才对。

修改以前 car2==Car{name='benz'}
修改以后 car2==Car{name='bmw'}
最终结果 main car1==Car{name='benz'}

从结果又能佐证这里依然是值传递。

若是是引用传递，本来的 0x1102 应该是被直接替换为新建立的 0x1103 才对；而实际状况如上图所示，car2 直接从新引用了一个对象，两个对象之间互不干扰。

Go

相对于 Java 来讲 Go 的用法又有所不一样，不过咱们也能够先得出结论：

Go语言的参数也是值传递。

在 Go 语言中数据类型主要有如下两种：

值类型与引用类型；

值类型

先以值类型举例：

func main() {
	a :=10
	modifyValue(a)
	fmt.Printf("最终 a=%v", a)
}

func modifyValue(a int) {
	a = 20
}
输出：最终 a=10

函数调用过程与以前的 Java 相似，本质上传递到函数中的值也是 a 的拷贝，因此对其的修改不会影响到原始数据。

当咱们把代码稍加修改：

func main() {
	a :=10
	fmt.Printf("传递以前a的内存地址%p \n", &a)
	modifyValue(&a)
	fmt.Printf("最终 a=%v", a)
}
	
func modifyValue(a *int) {
	fmt.Printf("传递以后a的内存地址%p \n", &a)
	*a = 20
}

传递以前a的内存地址0xc0000b4040 
传递以后a的内存地址0xc0000ae020
最终 a=20

从结果来看最终 a 的值是被方法修改了，这点即是 Go 与 Java 很大的不一样点：

在 Go 中存在着指针的概念，咱们能够将变量经过指针的方式传递到不一样的方法中，在方法里即可经过这个指针访问甚至修改原始数据。

那这么一看不就是引用传递嘛？

其实否则，咱们仔细看看刚才的输出会发现参数传递先后的内存地址并不相同。

传递以前a的内存地址0xc0000b4040 
传递以后a的内存地址0xc0000ae020

这也刚好论证了值传递，由于这里实际传递的是指针的拷贝。

也就是说 modifyValue 方法中的参数与入参的&a都是同一块内存的指针，但指针自己也是须要内存来存放的，因此在方法调用过程当中新建了一个指针 a ，从而致使他们的内存地址不一样。

虽然内存地址不一样，但指向的数据都是同一块，因此方法内修改后原始数据也受到了影响。

引用类型

对于 map slice channel 这类引用类型又略有不一样：

func main() {
	var personList = []string{"张三","李四"}
	modifySlice(personList)
	fmt.Printf("slice=%v \n", personList)
}
func modifySlice(personList []string) {
	personList[1] = "王五"
}

slice=[张三 王五]

最终咱们会发现原始数据也被修改了，但咱们并无传递指针；一样的特性也适用于 map 。

但其实咱们查看 slice 的源码会发现存放数据的 array 就是指针类型：

type slice struct {
	array unsafe.Pointer
	len   int
	cap   int
}

因此咱们能够直接对数据进行修改，至关于间接的带了指针。

---

使用建议

那咱们在何时使用指针呢？有如下几点建议：

• 若是参数是基本的值类型，好比 int,float 建议直接传值。
• 若是须要修改基本的值类型，那只能是指针；但考虑到代码可读性仍是建议将修改后的值返回用于从新赋值。
• 数据量较大时建议使用指针，减小没必要要的值拷贝。（具体多大能够自行判断）

Python

在 Python 中变量是否可变是影响参数传递的重要因素：

如上图所示，bool int float 这些不可变类型在参数传递过程当中是不能修改原始数据的。

if __name__ == '__main__':
		x = 1
    modify(x)
    print('最终 x={}'.format(x))	

def modify(val):
    val = 2

最终 x=1

原理与 Java Go中相似，是基于值传递的，这里就再也不复述。

这里重点看看可变数据类型在参数传递中的过程：

if __name__ == '__main__':
		x = [1]
    modify(x)
    print('最终 x={}'.format(x))	

def modify(val):
    val.append(2)

最终 x=[1, 2]

最终数据受到了影响，那么就代表这是引用传递嘛？再看个例子试试：

if __name__ == '__main__':
		x = [1]
    modify(x)
    print('最终 x={}'.format(x))	

def modify(val):
    val = [1, 2, 3]

最终 x=[1]

显而易见这并非引用传递，若是是引用传递最终 x 应当等于 [1, 2 ,3] 。

从结果来看这个传递过程很是相似 Go 中的指针传递，val 拿到的也是 x 这个参数内存地址的拷贝；他们都指向了同一块内存地址。

因此对这块数据的修改本质上改的是同一份数据，但一旦从新赋值就会建立一块新的内存从而不会影响到原始数据。

与 Java 中的上图相似。

因此总结下：

• 对于不可变数据：在参数传递时传递的是值，对参数的修改不会影响到原有数据。
• 对于可变数据：传递的是内存地址的拷贝，对参数的操做会影响到原始数据。

---

这么说来这三种都是值传递了，那有没有引用传递的语言呢？

固然，C++是支持引用传递的：

#include <iostream>
using namespace std;
 
class Box
{
   public:
      double len;
};

void modify(Box& b);
 
int main ()
{
	Box b1;
	b1.len=100;
	cout << "调用前，b1 的值：" << b1.len << endl;
	modify(b1);
	cout << "调用后，b1 的值：" << b1.len << endl;
	return 0;
}
 
void modify(Box& b)
{
	b.len=10.0;
	Box b2;
	b2.len = 999;
	b = b2;
  
	return;
}

调用前，b1 的值：100
调用后，b1 的值：999

能够看到把新对象 b2 赋值给入参 b 后是会影响到原有数据的。

总结

其实这几种语言看下来会发现他们中也有许多类似之处，因此一般咱们在掌握一门语言后也能快速学习其余语言。

但每每是这些基础中的基础最让人忽略，但愿你们在平常编码时可以考虑到这些基础知识多想一想必定会写出更漂亮的代码(bug)。