[求助]C++中运算符重载时出错

无双

对齐一下源码啊
libinary兄的筌名不是写得很清楚吗

太乱了没法看

DoDo

不好意思,这里重发一下.为什么没有编辑旧帖子的功能呢?

1. 
   
2. const int BASE=10;
   
3. class hInt
   
4. {
   
5.   private:
   
6.     int    sign;
   
7.     int    length;
   
8.     char * number;
   
9. 
   
10.     void new_number(int);
    
11.     void check();
    
12. 
    
13.     void abs_add(const hInt &,const hInt &);
    
14.     void abs_sub(const hInt &,const hInt &);
    
15.     int  abs_bes(const hInt &);
    
16.   public:
    
17.     hInt();
    
18.     hInt(char *);
    
19.     ~hInt();
    
20.     void to_str(char *);
    
21. 
    
22.     void operator=(const hInt &);
    
23.     void operator=(char *);
    
24.     hInt friend & operator+(const hInt &,const hInt &);
    
25. };
    
26. //private
    
27. void hInt::new_number(int i)
    
28. {
    
29.   delete []number;
    
30.   number=new char[i+1]; //note:char[i] is not necessary
    
31.   number[i]=0;      //but let char[i]=0 can make it easy to watch
    
32. }
    
33. void hInt::check()
    
34. {
    
35.   if(length<0) return; //error, maybe no chance to happen
    
36.   if(length==0) { sign=0; return; }
    
37.   char * p=number+length-1;
    
38.   while((*(p--)==0)&&(length>0)) length--;
    
39.   if(length==0) sign=0;
    
40. }
    
41. void hInt::abs_add(const hInt & ha,const hInt & hb)
    
42. {
    
43.   //length and number[] will be made up here, but nothing to do with sign
    
44.   int l1,l2;
    
45.   char * p1, * p2;
    
46.   if(ha.length>hb.length)
    
47.   { l1=ha.length; l2=hb.length; p1=ha.number; p2=hb.number; }
    
48.   else
    
49.   { l2=ha.length; l1=hb.length; p2=ha.number; p1=hb.number; }
    
50.   length=l1+1;
    
51.   new_number(length);
    
52.   char * p=number;
    
53.   int i;
    
54.   char t=0;
    
55.   for(i=0;i<l2;i++)
    
56.   {
    
57.     t+=*(p1++)+*(p2++);
    
58.     if(t>=BASE) { *(p++)=t-BASE; t=1; }
    
59.     else        { *(p++)=t     ; t=0; }
    
60.   }
    
61.   for(;i<l1;i++)
    
62.   {
    
63.     t+=*(p1++);
    
64.     if(t>=BASE) { *(p++)=t-BASE; t=1; }
    
65.     else        { *(p++)=t     ; t=0; }
    
66.   }
    
67.   *p=t;
    
68. }
    
69. void hInt::abs_sub(const hInt & ha,const hInt & hb)
    
70. {
    
71.   //abs(ha) mustn't be smaller than abs(hb)
    
72.   int l1=ha.length, l2=hb.length;
    
73.   char * p1=ha.number, * p2=hb.number;
    
74.   length=l1;
    
75.   new_number(length);
    
76.   char * p=number;
    
77.   int i;
    
78.   char t=0;
    
79.   for(i=0;i<l2;i++)
    
80.   {
    
81.     t+=*(p1++)-*(p2++);
    
82.     if(t>=0) { *(p++)=t     ; t= 0; }
    
83.     else     { *(p++)=t+BASE; t=-1; }
    
84.   }
    
85.   for(;i<l1;i++)
    
86.   {
    
87.     t+=*(p1++);
    
88.     if(t>=0) { *(p++)=t     ; t= 0; }
    
89.     else     { *(p++)=t+BASE; t=-1; }
    
90.   }
    
91. }
    
92. int hInt::abs_bes(const hInt & h)
    
93. {
    
94.   if(length>h.length) return 1;
    
95.   if(length<h.length) return -1;
    
96.   char * p1=number+length-1, * p2=h.number+length-1;
    
97.   for(int i=0;i<length;i++)
    
98.   {
    
99.     if(*p1>*p2) return 1;
    
100.     if(*p1<*p2) return -1;
     
101.     p1--; p2--;
     
102.   }
     
103.   return 0;
     
104. }
     
105. //public
     
106. hInt::hInt()
     
107. {
     
108.   number=new char[1];
     
109. }
     
110. hInt::hInt(char * s)
     
111. {
     
112.   number=new char[1];
     
113.   *this=s;
     
114. }
     
115. hInt::~hInt()
     
116. {
     
117.   delete []number;
     
118. }
     
119. void hInt::to_str(char * s)
     
120. {
     
121.   char * p=number+length-1;
     
122.   if(sign==-1) *(s++)='-';
     
123.   for(int i=0;i<length;i++) *(s++)=*(p--)+'0';
     
124.   if(i==0) *(s++)='0';
     
125.   *s=0;
     
126. }
     
127. void hInt::operator=(const hInt & h)
     
128. {
     
129.   sign=h.sign;
     
130.   length=h.length;
     
131.   new_number(length);
     
132.   char * p1=number;
     
133.   char * p2=h.number;
     
134.   for(int i=0;i<length;i++) *(p1++)=*(p2++);
     
135. }
     
136. void hInt::operator=(char * s)
     
137. {
     
138.   while(*s==' ') s++;
     
139.   sign=1;
     
140.   if(*s=='-') { sign=-1; s++; }
     
141.   if(*s=='+') s++;
     
142.   length=0;
     
143.   while((s[length]>='0')&&(s[length]<='9')) length++;
     
144.   if(length==0) return; //error
     
145.   new_number(length);
     
146.   for(int i=0;i<length;i++) number[length-i-1]=s[i]-'0';
     
147.   check();
     
148. }
     
149. hInt & operator+(const hInt & ha,const hInt & hb)
     
150. {
     
151.   hInt * h;
     
152.   h=new hInt;
     
153.   if(hb.sign==0) { *h=ha; return *h; }
     
154.   if(ha.sign==0) { *h=hb; return *h; }
     
155.   if(ha.sign==hb.sign)
     
156.   {
     
157.     h->sign=ha.sign;
     
158.     h->abs_add(ha,hb);
     
159.     h->check();
     
160.     return *h;
     
161.   }
     
162.   else
     
163.   {
     
164.     int t=ha.abs_bes(hb);
     
165.     if(t==0)
     
166.     {
     
167.       h->sign=0;
     
168.       h->length=1;
     
169.       h->new_number(1);
     
170.       *h->number=0;
     
171.       return *h;
     
172.     }
     
173.     if(t==1)
     
174.     {
     
175.       h->sign=ha.sign;
     
176.       h->abs_sub(ha,hb);
     
177.       h->check();
     
178.       return *h;
     
179.     }
     
180.     h->sign=hb.sign;
     
181.     h->abs_sub(hb,ha);
     
182.     h->check();
     
183.     return *h;
     
184.   }
     
185. }
     
186. //---------------------------------------------------------------------------
     
187. #include <iostream.h>
     
188. void set_str(char * t,const char * f)
     
189. {
     
190.   while(*(t++)=*(f++)) ;
     
191. }
     
192. void main()
     
193. {
     
194.   cout<<"test begin"<<endl;
     
195.   char s[256];
     
196.   hInt h1("1"),h2("9"),h3;
     
197.   h3=h1+h2;
     
198.   h3.to_str(s);
     
199.   cout<<s<<endl;
     
200.   cout<<"test end"<<endl;
     
201. }
     
202. //---------------------------------------------------------------------------
     

复制代码

libinary

说一下传参数和返回值类型的时候的复制构造函数，

1. 
   
2. class A{...};
   
3. A func(A a)
   
4. {
   
5.   return a;
   
6. }
   
7. int
   
8. main(void)
   
9. {
   
10.   A m, n;
    
11.   n = func(m);
    
12.   return(0);
    
13. }
    

复制代码

主要说func()，在main中调用n = func(m)时，首先调用复制构造函数把m复制给了a，而返回a的时候实际上返回了一个临时对象，首先调用复制构造函数把a复制给临时对象作为函数的返回，这是返回值的情况，如果返回引用就不会调用复制构造函数，因为实际返回的是地址，如果返回局部变量的引用的话就会遇到你说的变量已经析构的问题，如果返回值的话就可以，不过你的类有内存分配的问题，所以必须提供复制构造函数。

DoDo

多谢指点.但小弟愚笨,还是有点不太明白:

照版主这么说,如果直接返回值的话,系统会完成临时变量的申请和释放.
我在发现问题之前,程序就是

1. 
   
2. hInt operator+(const hInt & ha,const hInt & hb)
   
3. {
   
4.   hInt h;
   
5.   if(hb.sign==0) return ha;
   
6.   if(ha.sign==0) return hb;
   
7.   ......
   
8.   return h;
   
9. }
   

复制代码

这样的,直接返回其值,但当后来当计算的值稍大,比如:

1. 
   
2. void main()
   
3. {
   
4.   cout<<"test begin"<<endl;
   
5.   char s[256];
   
6.   hInt h1("1"),h2("9999999999999999999999"),h3;
   
7.   h3=h1+h2;
   
8.   h3.to_str(s);
   
9.   cout<<s<<endl;
   
10.   cout<<"test end"<<endl;
    
11. }
    

复制代码

当h3=h1+h2;执行完成后,h2的number地址不变,但内容却不对了,而程序中根本没有改变过h2.同时程序结束在释放h3再释放h2时就"该程序执行了非法操作"(我是在Windows98下的Turbo C++ 3.0环境下).我不知道是怎么回事

至于版主说的"复制构造函数",没听说过,书里也没有.我只知道构造函数.

我高中刚毕业,想提前学一下,所以是看书自学的,知识的掌握显然有很多漏洞,希望并且感谢大家的耐心帮助

无双

operator =什么会是返回void呢
应该是返回指针或是引用

DoDo

operator=应该是返回void啊,它不是对*this本身进行改变吗?

DoDo

关于libinary版主的回复我又想了想,是不是这个意思,一个类的实例创建后就不应该再为内部的指针申请内存?那operator=该怎样实现呢?

要不然我还是用这之前写的那个预先规定了最大长度的类得了.

libinary

你上面的问题主要就是没有提供复制构造函数，复制构造函数的形式是

1. 
   
2. class A{
   
3. public:
   
4.   A(const A &a){...}
   
5. ...
   
6. }

复制代码

带一个const A&或A&参数，比如对象初始化的时候就要用到复制构造函数：
A a;
A b(a); // 这里用到复制构造函数
如果你不提供复制构造函数的话，编译器就为你生成一个，就是按位拷贝，把b的数据直接拷到a里，你说的h2和h3的问题是因为位拷贝以后number是相同的，而number是一个指针，所以最后h2和h3中的number指向了同一个地址，h2的数据改变就是因为这个，“该程序执行了非法操作”是因为h2和h3析构的时候各自释放了number(delete)，当对number第二次delete的时候就出现了非法操作。

DoDo

是这样的!
我再试试.再次感谢!

libinary

类里重要的成员函数有构造函数、析构函数、复制构造函数、赋值运算符，复制构造函数和赋值运算符的作用比较象，但用的场合不同，如果类里有自己管理的指针的话一般这几个成员函数都要提供，否则就会出现错误，当然，如果你很小心的永远不使用初始化和赋值也没有问题，呵呵，实际上这是很难避免的。
再有，复制构造函数一般书里都讲，因为是很重要的成员函数，你再好好看看。