由swap引发的关于按值传递和引用传递的思考与总结 Passing Information to a Method or a Constructor

 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

 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

 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 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);//将类或者对象的成员变量，“暴露出来”，当成实参传递给形参，这种做法就有待商榷。

　　}
}