函数重载求解

ANONYMOUS419

1. #pragma once
   
2. class Complex
   
3. {
   
4.         double real_, imag_;
   
5. public:
   
6.         Complex();
   
7.         Complex(double, double);
   
8.         ~Complex();
   
9.         Complex & operator+=(const Complex &);
   
10.         Complex & operator-=(const Complex &);
    
11.         Complex & operator*=(const Complex &);
    
12.         Complex & operator/=(const Complex &);
    
13.         Complex & operator%=(const Complex &c2);
    
14.         Complex & operator^=(const Complex &);
    
15.         Complex & operator&=(const Complex &);
    
16.         Complex & operator|=(const Complex &);
    
17.         Complex & operator=(const Complex &);
    
18.         bool operator>=(const Complex &);
    
19.         bool operator<=(const Complex &);
    
20.         bool operator==(const Complex &);
    
21.         bool operator<(const Complex &);
    
22.         bool operator>(const Complex &);
    
23.         bool operator!=(const Complex &);
    
24.         Complex & operator++();
    
25.         Complex & operator--();
    
26.         Complex operator++(int);
    
27.         Complex operator--(int);
    
28. };
    
29. 
    
30. #include "Complex.h"
    
31. 
    
32. 
    
33. 
    
34. Complex::Complex()
    
35. {
    
36.         real_ = imag_ = 0;
    
37. }
    
38. 
    
39. Complex::Complex(double r, double i):real_(r),imag_(i)
    
40. {
    
41. 
    
42. }
    
43. 
    
44. Complex::~Complex()
    
45. {
    
46. }
    
47. 
    
48. Complex & Complex::operator+=(const Complex & c2)
    
49. {
    
50.         real_ += c2.real_;
    
51.         imag_ += c2.imag_;
    
52.         return *this;
    
53. }
    
54. 
    
55. Complex & Complex::operator-=(const Complex & c2)
    
56. {
    
57.         real_ -= c2.real_;
    
58.         imag_ -= c2.imag_;
    
59.         return *this;
    
60. }
    
61. 
    
62. Complex & Complex::operator*=(const Complex & c2)
    
63. {
    
64.         real_ *= c2.real_;
    
65.         imag_ *= c2.imag_;
    
66.         return *this;
    
67. }
    
68. 
    
69. Complex & Complex::operator/=(const Complex & c2)
    
70. {
    
71.         if (c2.real_&&c2.imag_)
    
72.         {
    
73.                 real_ /= c2.real_;
    
74.                 imag_ /= c2.imag_;        
    
75.         }
    
76. 
    
77.         return *this;
    
78. }
    
79. 
    
80. Complex & Complex::operator%=(const Complex & c2)
    
81. {
    
82.         int(real_) %= int(c2.real_);
    
83.         int(imag_) %= int(c2.imag_);
    
84.         return *this;
    
85. }
    
86. 
    
87. Complex & Complex::operator^=(const Complex &)
    
88. {
    
89.         // TODO: insert return statement here
    
90. }
    
91. 
    
92. Complex & Complex::operator&=(const Complex &)
    
93. {
    
94.         // TODO: insert return statement here
    
95. }
    
96. 
    
97. Complex & Complex::operator|=(const Complex &)
    
98. {
    
99.         // TODO: insert return statement here
    
100. }
     
101. 
     
102. Complex & Complex::operator=(const Complex &)
     
103. {
     
104.         // TODO: insert return statement here
     
105. }
     
106. 
     
107. bool Complex::operator>=(const Complex &)
     
108. {
     
109.         return false;
     
110. }
     
111. 
     
112. bool Complex::operator<=(const Complex &)
     
113. {
     
114.         return false;
     
115. }
     
116. 
     
117. bool Complex::operator==(const Complex &)
     
118. {
     
119.         return false;
     
120. }
     
121. 
     
122. bool Complex::operator<(const Complex &)
     
123. {
     
124.         return false;
     
125. }
     
126. 
     
127. bool Complex::operator>(const Complex &)
     
128. {
     
129.         return false;
     
130. }
     
131. 
     
132. bool Complex::operator!=(const Complex &)
     
133. {
     
134.         return false;
     
135. }
     
136. 
     
137. Complex & Complex::operator++()
     
138. {
     
139.         // TODO: insert return statement here
     
140. }
     
141. 
     
142. Complex & Complex::operator--()
     
143. {
     
144.         // TODO: insert return statement here
     
145. }
     
146. 
     
147. Complex Complex::operator++(int)
     
148. {
     
149.         return Complex();
     
150. }
     
151. 
     
152. Complex Complex::operator--(int)
     
153. {
     
154.         return Complex();
     
155. }
     
156. 
     

复制代码

1>------ Rebuild All started: Project: HomeWork2, Configuration: Debug Win32 ------
1>  Source.cpp
1>  Complex.cpp
1>e:\c++语法与数据结构\c++语法与数据结构第8天\homework2\homework2\complex.cpp(53): error C2106: '%=': left operand must be l-value
1>e:\c++语法与数据结构\c++语法与数据结构第8天\homework2\homework2\complex.cpp(54): error C2106: '%=': left operand must be l-value
1>  Generating Code...
========== Rebuild All: 0 succeeded, 1 failed, 0 skipped ==========

hellioncu

左边你加  int() 干啥？

zsszss0000

这个是什么编辑器，效果挺好的啊

hellioncu

zsszss0000 发表于 2015-04-28 08:51
这个是什么编辑器，效果挺好的啊

看最后的输出，应该是VS，修改了缺省的配色

cokeboL

回复 4# hellioncu


    也有点像sublime

shuxiaohua1989

你这开头 一看就有错误。
Complex & Complex:perator%=(const Complex & c2)
{
        int(real_) %= int(c2.real_);
        int(imag_) %= int(c2.imag_);
        return *this;
}
强制类型转换后是不能作为左值的。实际上强制类型转换你可以理解为：一个常量（你需要的类型），这个常量的值为原变量的值。当然编译器具体是怎么做的，你去学习相关的知识。
按照你的本意，代码应该这样改：
Complex & Complex:perator%=(const Complex & c2)
{
        real_=int(real_)% int(c2.real_);
         imag_= int(imag_)%int(c2.imag_);
        return *this;
}

ANONYMOUS419

谢谢大哥回复 6# shuxiaohua1989