这道题重载RMB& openator+=(double)和 RMB& openator-=(double);的代码怎么写

卡卡巴马

根据ch18_3.cpp，增加操作符，以允许作相应赋值。

   // RMB& openator+=(const RMB&);
   // RMB& openator+=(double);
   // RMB& openator-=(const RMB&);
   // RMB& openator-=(double);

// 在此处补充你的代码
int main()
{
        RMB d1(1,60);
        RMB d2(2,50);
        RMB d3;
        double db;
        cin>>db;
        d3 += d2;
        d3 += db; d3.display();
        d3 -= d1;
        d3 -= db; d3.display();
        return 0;
}
输入
1.11
输出
3.61
0.9
样例输入
1.11
样例输出
3.61
0.9
   
来源
钱能教材练习18.4

1. 根据ch18_3.cpp，增加操作符，以允许作相应赋值。
   
2. 
   
3.    // RMB& openator+=(const RMB&);
   
4.    // RMB& openator+=(double);
   
5.    // RMB& openator-=(const RMB&);
   
6.    // RMB& openator-=(double);
   
7. 
   
8. // 在此处补充你的代码
   
9. int main()
   
10. {
    
11.         RMB d1(1,60);
    
12.         RMB d2(2,50);
    
13.         RMB d3;
    
14.         double db;
    
15.         cin>>db;
    
16.         d3 += d2;
    
17.         d3 += db; d3.display();
    
18.         d3 -= d1;
    
19.         d3 -= db; d3.display();
    
20.         return 0;
    
21. }
    
22. 输入
    
23. 1.11
    
24. 输出
    
25. 3.61
    
26. 0.9
    
27. 样例输入
    
28. 1.11
    
29. 样例输出
    
30. 3.61
    
31. 0.9
    
32.    
    
33. 来源
    
34. 钱能教材练习18.4
    
35. #include <iostream>
    
36. using namespace std;
    
37. // 在此处补充你的代码
    
38. class RMB{
    
39.         public:
    
40.                 RMB(){
    
41.                 yuan=0;
    
42.                 jf=0;
    
43.         }
    
44.         RMB(double d);
    
45.         RMB(unsigned d,unsigned c);
    
46.         RMB operator+(RMB&) const;
    
47.         RMB& operator ++();
    
48.                 RMB& operator+=(const RMB& r);
    
49.                 RMB& operator-=(const RMB& r);
    
50.         void display ()const {
    
51.         cout<<(yuan+jf/100.0)<<endl;}
    
52.         RMB operator *(double d) const;
    
53.     protected:
    
54.             unsigned yuan;
    
55.             unsigned jf;
    
56.     };
    
57. RMB::RMB(double d){
    
58.         yuan=long(d);
    
59.         jf=((d-yuan)*1000+5)/10;
    
60. }
    
61. RMB::RMB(unsigned d,unsigned c){
    
62.         yuan=d+c/100;
    
63.         jf=c%100;
    
64. }
    
65. RMB RMB::operator+(RMB& s)const
    
66. {
    
67.         unsigned c=jf+s.jf;
    
68.         unsigned d=yuan+s.yuan;
    
69.         return RMB(d,c);
    
70. }
    
71. RMB&RMB::operator ++()
    
72. {
    
73.         yuan+=(jf+1)/100;
    
74.         jf=(jf+1)%100;
    
75.         return *this;
    
76. }
    
77. RMB& RMB::operator+=(const RMB& r){
    
78.         yuan+=r.yuan+(jf+r.jf)/100;
    
79.         jf=(jf+r.jf)%100;
    
80.         return *this;
    
81. }
    
82. RMB& RMB::operator-=(const RMB& r){
    
83.         if(yuan+jf/100.0<r.yuan+r.jf/100.0){
    
84.                 cout<<"error:the result is less than 0.\n";
    
85.                 return *this;
    
86.         }
    
87.         yuan-=r.yuan-((jf<r.jf)?1:0);
    
88.         jf=(jf+100-r.jf)%100;
    
89.         return *this;
    
90.       
    
91. }
    
92. RMB RMB::operator *(double d)const
    
93. {
    
94.         double temp=(yuan+jf/100.0)*d;
    
95.         unsigned y=long(temp);
    
96.         unsigned j=((temp-y)*1000+5)/10;
    
97.         return RMB(y,j);
    
98. }
    
99. RMB operator*(double d,const RMB&r){
    
100.         return r*d;
     
101. }
     
102. int main()
     
103. {
     
104.         RMB d1(1,60);
     
105.         RMB d2(2,50);
     
106.         RMB d3;
     
107.         double db;
     
108.         cin>>db;
     
109.         d3 += d2;
     
110.         d3 += db; d3.display();
     
111.         d3 -= d1;
     
112.         d3 -= db; d3.display();
     
113.         return 0;
     
114. }

复制代码