函数的参数传递定义：在调用一个函数时，将实参传递给形参。
C++中函数的参数传递有按值传递、地址传递和引用传递3种方式。注意：地址也是一种值，按值传递和按地址传递都是单向的值传递方式，即形参都不会回传给实参。但是由于地址的特殊性，地址传递可以间接地改变实参的值，所以分开讨论。
一、按值传递
函数本身不对实参进行操作。
1 #include<iostream>
2 using namespace std;
3 void swap(int,int);//函数声明
4
5 void main()
6
7 {
8
9 int a=2,b=3;
10
11 swap(a,b);//调用时，形参x、y重新申请了空间，把a、b值拷贝到形参，不对实参产生影响
12
13 cout<<"a = "<<a<<",b = "<<b<<endl;
14
15 }
16
17 void swap(int x,int y)//函数定义
18
19 {
20
21 int temp = x;
22
23 x = y;
24
25 y = temp;
26
27 }
28
29 执行结果如下：
30 a = 2，b = 3
二、地址传递
所谓地址传递，是指在函数定义时将形参生命成指针，这样调用函数时就需要指定地址形式的实参。
1 #include<iostream>
2 using namespace std;
3 void swap(int *,int *);//函数声明
4
5 void main()
6
7 {
8
9 int a=2,b=3;
10
11 swap(&a,&b);//swap中不是交换了x和y的值，而是交换了两个指针指向的两个地址处的值；因为同一地址的数据值是相同的，从而间接地达到了回传参数的目的
12
13 cout<<"a = "<<a<<",b = "<<b<<endl;
14
15 }
16
17 void swap(int *x,int *y)//函数定义
18
19 {
20
21 int temp = *x;//"*"符号表示取指针指向的值
22
23 *x = *y;
24
25 *y = temp;
26
27 }
28
29 执行结果如下：
30 a = 3，b = 2
三、引用传递
c++中变量名对应着内存的存储位置，可以使用一个特定的内存地址访问到它，引用则引入了变量的另一个名字（别名），它和这个变量有同一内存地址，对应用的操作，也就是对被它引用的变量的操作。
1 #include<iostream>
2 using namespace std;
3 void swap(int &,int &);//函数声明
4
5 void main()
6
7 {
8
9 int a=2,b=3;
10
11 swap(&a,&b);//将实参的地址放入C++为形参分配的内存空间中
12
13 cout<<"a = "<<a<<",b = "<<b<<endl;
14
15 }
16
17 void swap(int &x,int &y)//函数定义
18
19 {
20
21 int temp = x;//引用使用的时候，直接当变量名用
22
23 x = y;
24
25 y = temp;
26
27 }
28
29 执行结果如下：
30 a = 3，b = 2
Java中，swap函数什么时候使用，由于何种必要使用？
在类中，实现两个成员变量值交换的swap方法：
1 class Test
2
3 {
4
5 private int a;
6
7 private int b;
8
9
10
11 //swap函数没有使用形参的必要性，本身就可以直接操作内成员a，b，不存在参数拷贝,a,b值交换成功
12
13 public void swap()
14
15 {
16
17 int temp = this.a;
18
19 this.a = b;
20
21 this.b = temp;
22
23 }
24
25 }
交互一个数组中的两个元素的值
public static void main（String []args)
{
int a[] = {1,2};
int temp = a[0];
a[0] = a[1];
a[1] = temp;
System.out.println("a[0] = " + a[0] + ",a[1] = " + a[1]);
}
打印结果：
a[0] = 2,a[1] = 1
两个数组交换值
public static void main(String args[])
{
int a[] = {1,2};
int b[] = {3,4};
int temp[] = a;
a = b;
b = temp;
for(int i=0;i<a.length;i++)
{
System.out.print("a[" + i + "]=" + a[i] + " ");
}
System.out.println();
for(int j=0;j<b.length;j++)
{
System.out.print("b[" + j + "]=" +b[j] + " ");
}
}
打印结果：
a[0]=3 a[1]=4
b[0]=1 b[1]=2
对于引用数据类型
public class ReferValue
{
static String ss = "hello";
public static void change(String str)
{
str = "world";//调用change函数时，传ReferValue.ss,不能改变成员ss值。
// ss = "ss changed";//直接反问修改，可以改变ss值
} public static void main(String args[]) { change(ReferValue.ss);//将类或者对象的成员变量，“暴露出来”，当成实参传递给形参，这种做法就有待商榷。
}}
附Java官方文档对于函数参数传递的解释（出自：http://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html）：
Passing Information to a Method or a Constructor
Passing Primitive Data Type Arguments
Primitive arguments, such as an int or a double, are passed into methods by value. This means that any changes to the values of the parameters exist only within the scope of the method. When the method returns, the parameters are gone and any changes to them are lost. Here is an example:
public class PassPrimitiveByValue {
public static void main(String[] args) {
int x = 3;
// invoke passMethod() with
// x as argument
passMethod(x);
// print x to see if its
// value has changed
System.out.println("After invoking passMethod, x = " + x);
}
// change parameter in passMethod()
public static void passMethod(int p) {
p = 10;
}
}
When you run this program, the output is:
After invoking passMethod, x = 3
Passing Reference Data Type Arguments
Reference data type parameters, such as objects, are also passed into methods by value. This means that when the method returns, the passed-in reference still references the same object as before.However, the values of the object‘s fields can be changed in the method, if they have the proper access level.
For example, consider a method in an arbitrary class that moves Circle objects:
public void moveCircle(Circle circle, int deltaX, int deltaY) {
// code to move origin of circle to x+deltaX, y+deltaY
circle.setX(circle.getX() + deltaX);
circle.setY(circle.getY() + deltaY);
// code to assign a new reference to circle
circle = new Circle(0, 0);
}
Let the method be invoked with these arguments:
moveCircle(myCircle, 23, 56)
Inside the method, circle initially refers to myCircle.
The method changes the x and y coordinates of the object that circle references (i.e., myCircle) by 23 and 56, respectively. These changes will persist when the method returns.
Then circle is assigned a reference to a new Circle object with x = y = 0. This reassignment has no permanence, however, because the reference was passed in by value and cannot change. Within the method, the object pointed to by circle has changed, but, when the method returns, myCircle still references the same Circle object as before the method was called.