值传递与引用传递的比较

C++与Java中的值传递和引用传递比较

开头先阐明一下我个人理解的值传递与引用传递。值传递，从字面上来说就是传递一个变量的值，其内在机制其实是在内存中复制一个全新的变量，内容与其一样而已，所以值传递前后往往涉及在两个不同语句块中的两个局部变量，这也是为什么对形参的操作无法对实参造成影响的根本原因。至于引用传递（更标准的叫法是传递引用），从字面来说传递的是一种引用。其内在机制就是形参作为一种引用值与实参共享内存地址空间。简单来说就是同一个内存地址有两个不同的名字。这也就是为什么在引用传递中，对形参的改变会对实参造成影响。（上述的影响不包括对变量重新赋予一个新的地址，这种情况下文会讨论）

下面进入正题。实际上，Java里并没有严格意义上的引用传递（或者可以说根本没有，一些书上明确写到只有值传递）。而C++中有值传递和引用传递两种模式。但是值得注意的是Java中值传递的概念与C++有很大的不同。

下面对数据类型进行分类讨论，浅析C++与Java中的值传递与引用传递的区别。

对于基本数据类型值，如int，double，float，char等：

在C++中，基本数据类型值有值传递和引用传递两种模式。值传递简单的将基本数据类型的值传递给函数的形式参数。例如某C++源代码中:

#include<iostream>
using namespace std;

void f(double a){a = 3.3}

int main(){
double b = 5.5;
f(b);
cout << b << endl;//5.5

return 0;
}

在主函数中调用函数f（b）时，先将返回地址压栈，然后函数f新创建了一个名为a的double类型的局部变量，并且将b的值复制给a。所以a，b具有不同的地址，但具有相同的内容（值）。正因为如此，在函数f中对a的任何赋值操作都影响不到主函数中b的值。

变量	内存地址	值
a	0x1234	5.5->3.3
b	0xabcd	5.5

而引用传递，如下C++源码：

#include<iostream>
using namespace std;

void f(double& a){a = 3.3}

int main(){
double b = 5.5;
f(b);
cout << b << endl;//3.3

return 0;
}

此时在主函数中调用函数f时，并不会为a创建新的内存地址空间，而是将a视为b的别名，共享内存地址，即a与b的指针指向同一内存地址。所以在函数f中对a的任何改变，都会对b产生相同的影响（因为涉及了同一内存地址上的操作）。

变量	内存地址	值
a	0x1234	5.5->3.3
b	0x1234	5.5->3.3

在Java中，基本类型值只有值传递。其机制与C++中基本数据类型值传递一致。

对于数组：

C++中，数组只有值传递一种模式（这里传递的是地址的值）。C++中的数组名实际上该数组的指针，指针指向该数组的第一个元素。例如在如下C++源码中：

#include<iostream>
using namespace std;

double c[2] = { 9.9,10.1 };

void f(double a[]) {
	a[1] = 3.3;  
	a = c;
}

int main() {
	double b[2] = {1.1,2.2};
	f(b);
	for (int i = 0; i < 2; i++) {
		cout << b[i] << " ";//1.1 3.3 
	}

	return 0;
}

当调用函数f（b）时，在函数f的栈帧中为形式参数a创建了一个内存地址（此地址与b不同）来存储实参b的值，这里b的值其实是数组第一个元素的地址，所以a中存储的内容是数组b第一个元素的地址。所以在函数f中对数组b的任何改变（除了改变b中存储的数组地址，下文解释），比如赋值等操作，都会对a产生相同的影响。然而改变b当中存储的数组地址却对a无影响，因为a与b本质上是两个不同的变量，在内存中有不同的地址，只不过他们存储的数组地址是相同的罢了。例如在函数f中：a = c ，这条语句将c赋给了形参a，但这对b是不产生影响的。

变量	内存地址	值
a	0x1234	0x1111->0x2222
b	0xabcd	0x1111
c	0x4321	0x2222

在Java中，数组只有值传递。其机制C++中数组值传递一致。

对于对象：

在C++中，对象有值传递和引用传递两种模式。

#include<iostream>
using namespace std;

class Circle {
public:
	int radius;
	Circle() {
		radius = 1;
	}

	Circle(int radius) {
		this->radius = radius;
	}
};

Circle a(5);

void f1(Circle c) {
	c.radius = 3;
	c = a;
}

void f2(Circle& c) {
	c.radius = 3;
}

void f3(Circle& c) {
	c = a;
}

int main() {
	Circle b;
	f1(b);
	cout << b.radius << endl;//1
	f2(b);
	cout << b.radius << endl;//3
	f3(b);
	cout << b.radius << endl;//5

	return 0;
}

调用函数f1（b）时，系统为对象c开了一块内存（b与c地址不同），并把b的内容复制给c。b和c是两个不同的对象，地址不同，但具有相同的内容。所以在函数f1中对c的任何操作都对b无影响。引用传递则创建一个变量别名c来与b共享内存地址，所以操作同步。

而在Java中，对象只有值传递。但与C++中值传递的机制有些不同。

class Circle{
	public int radius;
	public Circle() {
		radius = 1;
	}
}

public class Test {
	public static void main(String[] args) {
		Circle a = new Circle();
		f(a);
		System.out.println(a.radius);//5
	}
	
	public static void f(Circle b) {
		b.radius = 5;
		b = new Circle();
	}
}

当调用函数f（a）时，传入引用变量b的是a的地址（在Java中Circle a 只声明了引用变量a，并不为a分配内存空间）。所以在函数f中任何对b的赋值操作（除改变对象本身）都会同步到a上。但是在函数f中不能改变对象a本身。例如b = new Circle()，对a是没有任何影响的。因为引用变量a与b是有不同的内存地址的，只不过他们存储的是相同的对象的地址，所以改变函数中形参本身不会对实参造成任何影响。

以上仅为个人理解，如有表述错误望指正