一个传递对象的疑惑

小飞俠

下面这个程序是对象传递，它存在着潜在的问题应该在参数里使用引用，我不太清楚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;
}

♀〓♂♀〓♂

你应该知道,当自定义的类型做为参数按值传递给函数时,就一定会调用拷贝构造函数这件事情吧?
如果你已经知道了,那好:
拷贝构造函数的效果我举个例子:
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

如果不用引用
ob只是一个临时的对象
它与a没有任何关系
只是他们的值相等
display(a);
这里只用到它的值
如果用引用
那么ob与 a 直接相关（是一个东西）
delete其中一个的话，就是全部

航母风云

哦
对不起
楼主
没看见你的new
这样的话，和wfpb一样
做一个拷贝吧，你用new了

亾莣乁靈柩

那是不是对象作为参数在不使用动态存储时最好是使用引用呢？对象作为参数传递的时候只能调用复制构造函数吗？
如果局部对象使用动态内存的话在对象，可不可以这样理解：
（1）如果对象传递对象的话会存在潜在问题
（2）如果引用传递的话局部对象，撤销时会造成实参内存丢失
（3）复制构造函数使局部变量和 实参不使用一个内存，失去局部变量也不会影响实参。

森林的眼泪

1. #include<iostream>
   
2. #include<cstdlib>
   
3. using namespace std;
   
4. 
   
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. };
    
19. 
    
20. myclass::myclass(int i)
    
21. {
    
22. cout<<"allocating";
    
23. p=new int;
    
24. *p=i;
    
25. }
    
26. 
    
27. myclass::myclass(const myclass & object)
    
28. {
    
29. p = new int;
    
30. *p = *(object.p);
    
31. }
    
32. 
    
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. }
    
48. 
    
49. void display(myclass ob) // 如果你会单步调试的话，你再试试 (myclass & ob)
    
50. {
    
51. cout<<ob.getval()<<'\n';
    
52. }
    
53. 
    
54. int main()
    
55. {
    
56. myclass a(10);
    
57. display(a);
    
58. 
    
59. system("pause");
    
60. return 0;
    
61. }
    
62. 
    

复制代码

大漠

myclass & myclass::operator =(const myclass & object)
{
if(this == &object)
return *this;
delete p;
p = new int;
*p = *(object.p);
return *this;
}

请问一下，为什么要重新给p分配空间？为什么要调用运算符的重载呢？我现在有些搞不清楚在程序里什么时候应该有运算符的重载出现？？辛苦了！！谢谢

若叶花吹雪

kai：
在你的version中，是不是用引用传递效率更高一些，这样就无需作出实参的一个副本了。

龍2132

chenchao,
是的。

Yaci

以下是引用chenchao在2006-5-22 21:09:00的发言：
kai：
在你的version中，是不是用引用传递效率更高一些，这样就无需作出实参的一个副本了。
但别滥用,有修改原数据的危险,有时局部变量也很好