新微赢技术网

标题: 一个传递对象的疑惑 [打印本页]
作者: 小飞俠    时间: 2009-11-3 02:18
标题: 一个传递对象的疑惑
下面这个程序是对象传递，它存在着潜在的问题应该在参数里使用引用，我不太清楚ob被销毁时，调用析构函数清除它所指向的内存，那它怎么还会被对象a使用？？？使用引用的话，就不必清除ob了吗？？

#include<iostream>
#include<cstdlib>
using namespace std;
class myclass{
int *p;
public:
myclass(int i);
~myclass();
int getval(){
return *p;};
myclass::myclass(int i){
cout<<"allocating";
p=new int;
*p=i;}
myclass::~myclass(){
cout<<"freeing";
delete p;
}
void display(myclass ob)
{cout<<ob.getval()<<'\n';
}
int main(){
myclass a(10);
display(a);
return 0;
}
作者: ♀〓♂♀〓♂    时间: 2009-11-3 02:18
你应该知道,当自定义的类型做为参数按值传递给函数时,就一定会调用拷贝构造函数这件事情吧?
如果你已经知道了,那好:
拷贝构造函数的效果我举个例子:
class A{int x;char *p;} class B{int y;char *fp;}
这里A就相当于是实参,B就相当于是形参;
那么系统默认拷贝函数(因为你没有自己显示的定义一个拷贝构造函数)开始执行;
B.y=A.x; B.fp=A.p;
注意第2个语句;2个指针指向一个地址!
所以当形参(局部变量)结束生命周期时,会释放内存.那作为实际参数的A的对象指针将迷路(迷途指针,随意指向一个内存);
当A的对象结束生命周期,这个对象的析构函数被调用,释放那个指针指向的未知的地方(非常危险).
引用传递:
相当于直接把A作为形式参数;这样就不用调用拷贝构造函数了.
作者: 莣囨孓love    时间: 2009-11-3 02:18
如果不用引用
ob只是一个临时的对象
它与a没有任何关系
只是他们的值相等
display(a);
这里只用到它的值
如果用引用
那么ob与 a 直接相关（是一个东西）
delete其中一个的话，就是全部
作者: 航母风云    时间: 2009-11-3 02:18
哦
对不起
楼主
没看见你的new
这样的话，和wfpb一样
做一个拷贝吧，你用new了
作者: 亾莣乁靈柩    时间: 2009-11-3 02:18
那是不是对象作为参数在不使用动态存储时最好是使用引用呢？对象作为参数传递的时候只能调用复制构造函数吗？
如果局部对象使用动态内存的话在对象，可不可以这样理解：
（1）如果对象传递对象的话会存在潜在问题
（2）如果引用传递的话局部对象，撤销时会造成实参内存丢失
（3）复制构造函数使局部变量和 实参不使用一个内存，失去局部变量也不会影响实参。
作者: 森林的眼泪    时间: 2009-11-3 02:18
  1. #include<iostream>
  2. #include<cstdlib>
  3. using namespace std;

  5. class myclass
  6. {
  7. int * p; //由于需要动态开辟空间，一定要小心，
  8. // 你为此需要 copy constructor 和 assignment operator
  9. public:
  10. myclass(int i);
  11. myclass(const myclass & object);
  12. myclass & operator=(const myclass & object);
  13. ~myclass();
  14. int getval()
  15. {
  16. return *p;
  17. }
  18. };

  20. myclass::myclass(int i)
  21. {
  22. cout<<"allocating";
  23. p=new int;
  24. *p=i;
  25. }

  27. myclass::myclass(const myclass & object)
  28. {
  29. p = new int;
  30. *p = *(object.p);
  31. }

  33. myclass & myclass::operator =(const myclass & object)
  34. {
  35. if(this == &object)
  36. return *this;
  37. delete p;
  38. p = new int;
  39. *p = *(object.p);
  40. return *this;
  41. }
  42. myclass::~myclass()
  43. {
  44. cout<<"freeing";
  45. if(p)
  46. delete p;
  47. }

  49. void display(myclass ob) // 如果你会单步调试的话，你再试试 (myclass & ob)
  50. {
  51. cout<<ob.getval()<<'\n';
  52. }

  54. int main()
  55. {
  56. myclass a(10);
  57. display(a);

  59. system("pause");
  60. return 0;
  61. }

复制代码
作者: 大漠    时间: 2009-11-3 02:18
myclass & myclass::operator =(const myclass & object)
{
if(this == &object)
return *this;
delete p;
p = new int;
*p = *(object.p);
return *this;
}

请问一下，为什么要重新给p分配空间？为什么要调用运算符的重载呢？我现在有些搞不清楚在程序里什么时候应该有运算符的重载出现？？辛苦了！！谢谢
作者: 若叶花吹雪    时间: 2009-11-3 02:18
kai：
在你的version中，是不是用引用传递效率更高一些，这样就无需作出实参的一个副本了。
作者: 龍2132    时间: 2009-11-3 02:18
chenchao,
是的。
作者: Yaci    时间: 2009-11-3 02:18
以下是引用chenchao在2006-5-22 21:09:00的发言：
kai：
在你的version中，是不是用引用传递效率更高一些，这样就无需作出实参的一个副本了。
但别滥用,有修改原数据的危险,有时局部变量也很好



欢迎光临 新微赢技术网 (http://bbs.weiying.cn/) Powered by Discuz! X3.2