Chinaunix首页 | 论坛 | 博客

权镜士的ChinaUnix博客

首页　| 　博文目录　| 　关于我

权镜士

  • 博客访问： 268421
  • 博文数量： 88
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 840
  • 用 户 组： 普通用户
  • 注册时间： 2014-04-20 21:13
文章分类

全部博文（88）

文章存档

2022年（1）

2017年（1）

2016年（2）

2015年（1）

2014年（83）

我的朋友
最近访客
推荐博文
相关博文
关于C、C++、java中交换值或对象的思考

分类： Java

2014-04-20 22:40:41

C、C++和Java想必大部分人都认为自己或多或少懂得点。但要提起“最简单”的交换问题，恐怕有些人就不能那么快的答得很好了。
直接交换当然很容易。但是专门写一个函数做交换，在C、C++、Java中情况各自如何呢？

首先说一下结论，在C、C++中，可以通过传指针和传引用的方式来交换值。在java中，传值给函数参数只能是拷贝，所以用函数是不能交换值的。

先总结一下C/C++中指针传递和引用传递的问题

指针传递参数本质上是值传递的方式，它所传递的是一个地址值。值传递过程中，被调函数的形式参数作为被调函数的局部变量处理，即在栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行，不会影响主调函数的实参变量的值。（这里是在说实参指针本身的地址值不会变）

 

而在引用传递过程中，被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址（int &a的形式）。被调函数对形参的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。
 

引用传递和指针传递是不同的，虽然它们都是在被调函数栈空间上的一个局部变量，但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数，如果改变被调函数中的指针地址，它将影响不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量，那就得使用指向指针的指针，或者指针引用。

为了进一步加深大家对指针和引用的区别，下面我从编译的角度来阐述它们之间的区别：

程序在编译时分别将指针和引用添加到符号表上，符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值，而引用在符号表上对应的地址值为引用对象的地址值。符号表生成后就不会再改，因此指针可以改变其指向的对象（指针变量中的值可以改），而引用对象则不能修改。

最后，总结一下指针和引用的相同点和不同点：

★相同点：

●都是地址的概念；

指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名。

★不同点：

●指针是一个实体，而引用仅是个别名；

●引用只能在定义时被初始化一次，之后不可变；指针可变；引用“从一而终”，指针可以“见异思迁”；

●引用没有const，指针有const，const的指针不可变；（具体指没有int& const a这种形式，而const int& a是有     的，  前者指引用本身即别名不可以改变，这是当然的，所以不需要这种形式，后者指引用所指的值不可以改变）

●引用不能为空，指针可以为空；

●“sizeof 引用”得到的是所指向的变量(对象)的大小，而“sizeof 指针”得到的是指针本身的大小；

●指针和引用的自增(++)运算意义不一样；

●引用是类型安全的，而指针不是 (引用比指针多了类型检查


一、引用的概念

引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似，只是用&代替了*。
例如： Point pt1(10,10);
Point &pt2=pt1; 定义了pt2为pt1的引用。通过这样的定义，pt1和pt2表示同一对象。
需要特别强调的是引用并不产生对象的副本，仅仅是对象的同义词。因此，当下面的语句执行后：
pt1.offset（2，2）；
pt1和pt2都具有（12，12）的值。
引用必须在定义时马上被初始化，因为它必须是某个东西的同义词。你不能先定义一个引用后才
初始化它。例如下面语句是非法的：
Point &pt3；
pt3=pt1；
那么既然引用只是某个东西的同义词，它有什么用途呢？
下面讨论引用的两个主要用途：作为函数参数以及从函数中返回左值。

二、引用参数

1、传递可变参数
传统的c中，函数在调用时参数是通过值来传递的，这就是说函数的参数不具备返回值的能力。
所以在传统的c中，如果需要函数的参数具有返回值的能力，往往是通过指针来实现的。比如，实现
两整数变量值交换的c程序如下：

点击(此处)折叠或打开

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

使用引用机制后，以上程序的c++版本为：

点击(此处)折叠或打开

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

调用该函数的c++方法为：swapint（x,y); c++自动把x,y的地址作为参数传递给swapint函数。  
  无论你传值还是传指针，函数都会生成一个临时变量，  

  但传引用时，不会生成临时变量，  
   
  当你传值时，只可以引用值而不可以改变值，但传值引用时，可以改变值， 
  当你传指针时，只可以改变指针所指的内容，不可以改变指针本身，但传指针引用时，既可以改变指针所指的内容，又可以改变指针本身，  
   
  但传引用主要是它不生成临时变量，不进行返回值copy等，速度快。  

  数据结构的二叉排序树中有典型应用..

注：简单一点可以这么想，如果不用引用的话，被传递的参数本身是不能被修改的，  
  即使你传递的是指针，也只能修改指针指向的内容，不能修改指针本身。  
  如果要修改当前被传递的参数的话，要么再加一级指针，要么用引用。


在java中，参数传递是通过传值（对于对象类型，传递的是引用的拷贝），所以常规的交换实现不了两个对象的交换，下面是测试代码：
Java代码  

点击(此处)折叠或打开

  1. import org.apache.commons.beanutils.BeanUtils; 
  2. public class Employee {
  3.     // Properties
  4.     private int id;
  5.     private String name

  7.     // Constructors
  8.     public Employee() {
  9.     }
  10.        
  11.     public Employee(int id, String name) {
  12.         this.id = id;
  13.         this.name = name;
  14.     }
  15.        
  16.     // get、set methods
  17.     public int getId() {
  18.         return id;
  19.     }
  20.     
  21.     public void setId(int id) {
  22.         this.id = id;
  23.     }
  24.   
  25.     public String getName() {
  26.         return name;
  27.     }
  28.   
  29.     public void setName(String name) {
  30.         this.name = name;
  31.     }
  32.        
  33.     // 无效的交换
  34.     public static void swap(Employee x, Employee y) {
  35.         Employee temp = x;
  36.         x = y;
  37.         y = temp;
  38.     }
  39.        
  40.     // 使用 BeanUtils 方法的有效交换
  41.     public static void swapByBeanUtils(Employee x, Employee y) {
  42.         try {
  43.             // clone x to temp
  44.             Employee temp = (Employee)BeanUtils.cloneBean(x);
  45.             // copyProperties from y to x
  46.             BeanUtils.copyProperties(x, y);
  47.             // copyProperties from temp to y
  48.             BeanUtils.copyProperties(y, temp);
  49.             // then, the Properties values of x,y has been swaped.
  50.         } catch (Exception e) {
  51.             e.printStackTrace();
  52.         }
  53.     }
  54.        
  55.     // 有人提出使用交换数组等集合里的元素 来实现交换，这样也是无效的
  56.     public static void swapByArray(Object[] a, int i, int j) {
  57.         Object t = a[i];
  58.         a[i] = a[j];
  59.         a[j] = t;
  60.     }
  61.        
  62.     public static void main(String[] args) {
  63.         Employee a = new Employee(1, "Bob");
  64.         Employee b = new Employee(2, "Jack");
  65.            
  66.         // 直接方法调用交换 -- NO
  67. // swap(a, b);
  68.            
  69.         // 利用BeanUtils交换 -- YES
  70. // swapByBeanUtils(a, b);
  71.            
  72.         // 利用 交换数据 思想 -- NO
  73. // Object[] o = {a, b};
  74. // swapByArray(o, 0, 1);
  75.            
  76.         // 直接交换 -- YES
  77. // Employee temp = a;
  78. // a = b;
  79. // b = temp;
  80.            
  81.         System.out.println(a);
  82.         System.out.println(b);
  83.     }
  84.        
  85.     // method for print
  86.     public String toString() {
  87.         StringBuilder sb = new StringBuilder();
  88.         sb.append("id: ").append(id).append(" name: ").append(name);
  89.         return sb.toString();
  90.     }
  91. }
  92. import org.apache.commons.beanutils.BeanUtils;
  93. public class Employee {
  94. // Properties
  95. private int id;
  96. private String name;

  98. // Constructors
  99. public Employee() {
  100. }

  102. public Employee(int id, String name) {
  103. this.id = id;
  104. this.name = name;
  105. }

  107. // get、set methods
  108. public int getId() {
  109. return id;
  110. }
  111. public void setId(int id) {
  112. this.id = id;
  113. }
  114. public String getName() {
  115. return name;
  116. }
  117. public void setName(String name) {
  118. this.name = name;
  119. }

  121. // 无效的交换
  122. public static void swap(Employee x, Employee y) {
  123. Employee temp = x;
  124. x = y;
  125. y = temp;
  126. }

  128. // 使用 BeanUtils 方法的有效交换
  129. public static void swapByBeanUtils(Employee x, Employee y) {
  130. try {
  131. // clone x to temp
  132. Employee temp = (Employee)BeanUtils.cloneBean(x);
  133. // copyProperties from y to x
  134. BeanUtils.copyProperties(x, y);
  135. // copyProperties from temp to y
  136. BeanUtils.copyProperties(y, temp);
  137. // then, the Properties values of x,y has been swaped.
  138. } catch (Exception e) {
  139. e.printStackTrace();
  140. }
  141. }

  143. // 有人提出使用交换数组等集合里的元素 来实现交换，这样也是无效的
  144. public static void swapByArray(Object[] a, int i, int j) {
  145.    Object t = a[i];
  146.    a[i] = a[j];
  147.    a[j] = t;
  148. }

  150. public static void main(String[] args) {
  151. Employee a = new Employee(1, "Bob");
  152. Employee b = new Employee(2, "Jack");

  154. // 直接方法调用交换 -- NO
  155. //     swap(a, b);

  157. // 利用BeanUtils交换 -- YES
  158. //     swapByBeanUtils(a, b);

  160. // 利用 交换数据 思想 -- NO
  161. //     Object[] o = {a, b};
  162. //     swapByArray(o, 0, 1);

  164.       // 直接交换 -- YES
  165. //     Employee temp = a;
  166. //     a = b;
  167. //     b = temp;

  169. System.out.println(a);
  170. System.out.println(b);
  171. }

  173. // method for print
  174. public String toString() {
  175. StringBuilder sb = new StringBuilder();
  176. sb.append("id: ").append(id).append(" name: ").append(name);
  177. return sb.toString();
  178. }
  179. }
 2. 结论
在java中，对象引用是通过值来传递的，方法不能修改参数指向新的对象。
 
注：需加载 BeanUtils包


附加思考：java中，用函数交换两个对象可以交换吗？
传参数时，是按引用传递的，但传递的是引用的值。有点拗口，大家品味下。结论是依然无法交换。参考：关于Java交换两个对象的问题

阅读(1110) | 评论(1) | 转发(0) |
0

上一篇：使用java连接MySql，中文乱码彻底解决的方法

下一篇：String s = new String("abc");创建了几个String Object?

给主人留下些什么吧！~~

7大爷2014-04-21 11:07:54

不错不错！

回复 | 举报
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6