由swap引发的关于按值传递和引用传递的思考与总结

　　函数的参数传递定义：在调用一个函数时，将实参传递给形参。

 

　　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方法：

class Test

{

　　private int a;

　　private int b;



　　//swap函数没有使用形参的必要性，本身就可以直接操作内成员a，b，不存在参数拷贝,a,b值交换成功

　　public void swap()

　　{

　　　　int temp = this.a;

　　　　this.a = b;

　　　　this.b = temp;

　　}　　

}

 

 

交互一个数组中的两个元素的值(可以画内存图分析，“栈中一小块内存指向堆中一大块内存，每new一次，就有新的指向”，如 Node ns[] = new Node[3]; ns[0] = new Node(0);)

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 void changeRefNode()
    {
        Node nodes[] = new Node[2];
        nodes[0] = new Node(0);
        nodes[1] = new Node(1);
        Node temp = nodes[0];
        nodes[0] = nodes[1];
        nodes[1] = temp;
        System.out.println(nodes[0].n + " " + nodes[1].n);
        //打印：1 0，交换成功
                
    }

 

 两个数组交换值

    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);//会修改myCircle的成员变量y的值；通过set方法
        
    // code to assign a new reference to circle
    circle = new Circle(0, 0);//不会修改引用myCircle的指向
}

 

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.    (circle = new Circle(0, 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.