c/c++和java实现swap函数的不同处

c/c++和java实现swap函数的不同处

2014-05-06 11:59 2255人阅读 评论(0)收藏举报

本文章已收录于：

分类：

C/C++ Vs Java（2）

作者同类文章X

版权声明：本文为博主原创文章，未经博主允许不得转载。

首先我们来看一下在c/c++中实现的swap函数

[cpp] view plain copy print?

1. void  swap ( int & a, int & b)      
2. {      
3.     int  Temp;      
4.     temp = a;      
5.     a = b;      
6.     b = temp;      
7. }  

void  swap ( int & a, int & b)    {        int  Temp;        temp = a;        a = b;        b = temp;    }

那么在java中是否还能这样呢，很显然java中没有地址引用符号了。

首先我们来看下c/c++和java的区别。

本质区别

C/C++中swap功能的本质：通过传递变量地址(指针或引用)来交换变量地址中的值。

Java标榜其中对C/C++一个很大的改进就是：Java对程序员屏蔽了变量地址的概念，减少指针误用。

在Java世界中函数或者叫方法的入参都是通过值拷贝的方式进行传递：

• 原始类型(char，int，double等）都是通过直接拷贝变量值传参；
• 对象类型都是通过引用拷贝(跟C++中引用不同)传参，通过该引用能够更改其指向的对象内部值，但是更改该引用值，仅对函数内部可见，函数外部的实参依然没有改变；

从上面可以看出通过地址的方式在java中是不可能实现的，因为java严格遵循值传递(pass-by-value)。

java传递是引用的拷贝，既不是引用本身，更不是对象。

但没有解决不了的问题，我们可以利用其他方法来实现：

Method1：用数组交换值（对于数组中的元素的交换，所以经常在排序中看到）

[java] view plain copy print?

1. Public  static  void  swap ( int [] Data,  int  a,  int  b) {  
2.         int  t = Data [a];      
3.         data [a] = data [b];      
4.         data [b] = t;      
5. }  

Public  static  void  swap ( int [] Data,  int  a,  int  b) {        int  t = Data [a];            data [a] = data [b];            data [b] = t;    }

Method2：用重定义类（自己定义的）

[java] view plain copy print?

1. Class  MyInteger {         
2.     Private  int  x;     / / the x as the only data member       
3.     Public  MyInteger ( int  xIn) {x = xIn;}  / / Constructor       
4.     Public  int  getValue () {  return  x;}   / / get the value        
5.     Public  void  insertValue ( int  xIn) {x = xIn;}  / / change the value of the      
6. }      
7.    
8. Public  Class  Swapping {         
9.     / / Swap: pass object references       
10.     static  void  swap (MyInteger rWrap, MyInteger sWrap) {            
11.         / / Change the value of the process           
12.         int  t = rWrap.getValue ();            
13.         rWrap.insertValue (sWrap.getValue ());            
14.         sWrap.insertValue (t);         
15.     }         
16.     Public  static  void  main (String [] args) {            
17.         int  a =  23 , b =  47 ;            
18.         System.out.println ( "Before. a:"  + a +  ", b:"  + b);            
19.         MyInteger AWRAP =  new  MyInteger (a);            
20.         MyInteger bWrap =  new  MyInteger (b);            
21.         swap (aWrap, bWrap);            
22.         a = aWrap.getValue ();            
23.         b = bWrap.getValue ();            
24.         System.out.println ( "After. a:"  + a +  ", b:"  + b);         
25.     }      
26. }  

Class  MyInteger {           Private  int  x;     / / the x as the only data member         Public  MyInteger ( int  xIn) {x = xIn;}  / / Constructor         Public  int  getValue () {  return  x;}   / / get the value          Public  void  insertValue ( int  xIn) {x = xIn;}  / / change the value of the    }     Public  Class  Swapping {           / / Swap: pass object references         static  void  swap (MyInteger rWrap, MyInteger sWrap) {                  / / Change the value of the process                 int  t = rWrap.getValue ();                  rWrap.insertValue (sWrap.getValue ());                  sWrap.insertValue (t);           }           Public  static  void  main (String [] args) {                  int  a =  23 , b =  47 ;                  System.out.println ( "Before. a:"  + a +  ", b:"  + b);                  MyInteger AWRAP =  new  MyInteger (a);                  MyInteger bWrap =  new  MyInteger (b);                  swap (aWrap, bWrap);                  a = aWrap.getValue ();                  b = bWrap.getValue ();                  System.out.println ( "After. a:"  + a +  ", b:"  + b);           }    }

Method3：外部内联法

[java] view plain copy print?

1. Public  Class  Swap2 {       
2.     Public  static  void  main (String args []) {       
3.         Swap2 SW =  new  Swap2 ( 1 , 2 );       
4.         System.out.println ( "i is"  + sw.i);       
5.         System.out.println ( "J is"  + sw.j);       
6.         sw.swap ();       
7.         System.out.println ( "i is"  + sw.i);       
8.         System.out.println ( "J is"  + sw.j);       
9.     }       
10.     int  i, J;       
11.     Public  Swap2 ( int  i,  int  J) {       
12.         this . i = i;       
13.         this . J = J;       
14.     }       
15.    
16.     Public   void  swap () {       
17.         int  Temp;       
18.         temp = i;       
19.         i = j;       
20.         j = temp;       
21.     }       
22. }       
23.    
24. Public  Class  swap1 {       
25.     Public  static  void  swap1 (Integer a, Integer b) {       
26.         Integer temp = a;       
27.         a = b;       
28.         b = temp;       
29.     }       
30.     Public   static   void  main (String args []) {       
31.         Integer a, b;       
32.         a =  new  Integer ( 10 );       
33.         b =  new  Integer ( 20 );       
34.         Swap1.Swap1 (a, b);       
35.         System.out.println ( "a is"  + a);       
36.         System.out.println ( "b is"  + b);       
37.     }       
38. }  

Public  Class  Swap2 {         Public  static  void  main (String args []) {             Swap2 SW =  new  Swap2 ( 1 , 2 );             System.out.println ( "i is"  + sw.i);             System.out.println ( "J is"  + sw.j);             sw.swap ();             System.out.println ( "i is"  + sw.i);             System.out.println ( "J is"  + sw.j);         }         int  i, J;         Public  Swap2 ( int  i,  int  J) {             this . i = i;             this . J = J;         }          Public   void  swap () {             int  Temp;             temp = i;             i = j;             j = temp;         }     }      Public  Class  swap1 {         Public  static  void  swap1 (Integer a, Integer b) {             Integer temp = a;             a = b;             b = temp;         }         Public   static   void  main (String args []) {             Integer a, b;             a =  new  Integer ( 10 );             b =  new  Integer ( 20 );             Swap1.Swap1 (a, b);             System.out.println ( "a is"  + a);             System.out.println ( "b is"  + b);         }     }

总结：

数组中的元素交换，可以使用下文中的public static void swap(int[] data, int a, int b)方法；
非数组中的元素交换，可以使用最原始的交换方法，可以实现交换；也可以使用上面提到的重定义类的方式、外部内联的方式，视情况而定

顶

1

踩

0

 

 

• 上一篇《Thinking in Algorithm》16.堆结构之斐波那契堆
• 下一篇c语言之struct

public  class  Swap1 {      
   public  static  void  Swap1 (Integer a, Integer b) {      
       Integer temp = a;      
       a = b;      
       b = temp;      
   }
     
   public   static   void  main (String args []) {      
       Integer a, b;      
       a =  new  Integer ( 10 );      
       b =  new  Integer ( 20 );      
       Swap1.Swap1 (a, b);      
       System.out.println ( "a is"  + a);      
       System.out.println ( "b is"  + b);      
   } 
//javac Swap1.java
//java Swap1
//a is10
//b is20
}