第八周实验报告2

最新推荐文章于 2022-06-06 17:14:26 发布
yuchenziyou
最新推荐文章于 2022-06-06 17:14:26 发布
阅读量299
点赞数
文章标签： c system html 任务
本文链接：https://blog.csdn.net/yuchenziyou/article/details/7441221
版权
/* (程序头部注释开始)
* 程序的版权和版本声明部分
* 文件名称：实现复数类中的运算符重载
* 作者：于宸
* 完成日期： 2012 年04 月08 日
* 版本号：1.0
* 对任务及求解方法的描述部分
* 输入描述：
* 问题描述：定义一个复数类重载运算符+、-、*、/，使之能用于复数的加减乘除。
* 程序输出：
* 程序头部的注释结束
[html]view plaincopy 
   
 #include<iostream>  
   
 using namespace std;  
   
 class CTime  
 {  
 private:  
       
     /*unsigned short */int hour;  
       
     /*unsigned short */int minute;  
       
     /*unsigned short */int second;  
       
 public:  
       
     CTime(int h = 0, int m =0, int s = 0);  
       
     //  void setTime(int h, int m, int s);//不知道有啥用···  
       
     void display();  
       
     //比较运算符（二目）的重载  
       
     bool operator > (CTime &t);  
       
     bool operator < (CTime &t);  
       
     bool operator >= (CTime &t);  
       
     bool operator <= (CTime &t);  
       
     bool operator == (CTime &t);  
       
     bool operator != (CTime &t);  
       
     //二目运算符的重载  
       
     CTime operator+(CTime &c);//返回c所规定的时·分·秒后的时间  
       
     CTime operator-(CTime &c);  
       
     CTime operator+(int s);  
       
     CTime operator-(int s);  
       
     //一目运算符的重载  
       
     CTime operator ++(int);//后置++，下一秒  
       
     CTime operator ++();//前置++，下一秒，前置与后置返回值不一样  
       
     CTime operator --(int);//后置--，前一秒  
       
     CTime operator --();//前置--，前一秒  
       
     //赋值运算符的重载  
       
     CTime operator +=(CTime &c);  
       
     CTime operator -=(CTime &c);  
             
     CTime operator +=(int s);  
             
     CTime operator -=(int s);  
 };  
   
 void CTime::display()  
 {  
     cout << hour << ":" << minute << ":" << second << endl;  
       
     return;  
 }  
   
 CTime::CTime(int h , int m, int s)  
 {  
     hour = h;  
       
     minute = m;  
       
     second = s;  
 }  
   
 bool CTime::operator >(CTime &t)  
 {  
     if(hour > t.hour)  
     {  
         return true;  
     }  
     else  
     {  
         if(minute > t.minute)  
         {  
             return true;  
         }  
         else  
         {  
             if(second > t.second)  
             {  
                 return true;  
             }  
             else  
             {  
                 return false;  
             }  
         }  
     }  
 }  
   
 bool CTime::operator <(CTime &t)  
 {  
     if(hour < t.hour)  
     {  
         return true;  
     }  
     else  
     {  
         if(minute < t.minute)  
         {  
             return true;  
         }  
         else  
         {  
             if(second < t.second)  
             {  
                 return true;  
             }  
             else  
             {  
                 return false;  
             }  
         }  
     }  
 }  
   
 bool CTime::operator >=(CTime &t)  
 {  
     if(hour >= t.hour)  
     {  
         return true;  
     }  
     else  
     {  
         if(minute >= t.minute)  
         {  
             return true;  
         }  
         else  
         {  
             if(second >= t.second)  
             {  
                 return true;  
             }  
             else  
             {  
                 return false;  
             }  
         }  
     }  
 }  
   
 bool CTime::operator <=(CTime &t)  
 {  
     if(hour <= t.hour)  
     {  
         return true;  
     }  
     else  
     {  
         if(minute <= t.minute)  
         {  
             return true;  
         }  
         else  
         {  
             if(second <= t.second)  
             {  
                 return true;  
             }  
             else  
             {  
                 return false;  
             }  
         }  
     }  
 }  
   
 bool CTime::operator ==(CTime &t)  
 {  
     if(hour == t.hour)  
     {  
         return true;  
     }  
     else  
     {  
         if(minute == t.minute)  
         {  
             return true;  
         }  
         else  
         {  
             if(second == t.second)  
             {  
                 return true;  
             }  
             else  
             {  
                 return false;  
             }  
         }  
     }  
 }  
   
   
 bool CTime::operator !=(CTime &t)  
 {  
     if(hour != t.hour)  
     {  
         return true;  
     }  
     else  
     {  
         if(minute != t.minute)  
         {  
             return true;  
         }  
         else  
         {  
             if(second != t.second)  
             {  
                 return true;  
             }  
             else  
             {  
                 return false;  
             }  
         }  
     }  
 }  
   
 CTime CTime::operator +(CTime &c)  
 {  
     CTime c1;  
       
     c1.hour = hour + c.hour;  
       
     c1.minute = minute + c.minute;  
       
     c1.second = second + c.second;  
       
     if(c1.second >= 60)  
     {  
         c1.second = c1.second - 60;  
           
         c1.minute = c1.minute + 1;  
     }  
       
     if(c1.minute >= 60)  
     {  
         c1.minute = c1.minute - 60;  
           
         c1.hour = c1.hour + 1;  
     }  
       
     if(c1.hour >= 24)  
     {  
         c1.hour = c1.hour -24;  
     }  
       
     return c1;  
 }  
   
 CTime CTime::operator -(CTime &c)  
 {  
     CTime c1;  
       
     c1.hour = hour - c.hour;  
       
     c1.minute = minute - c.minute;  
       
     c1.second = second - c.second;  
       
     if(c1.second < 0)  
     {  
         c1.second = 60 + c1.second;  
           
         c1.minute = c1.minute - 1;  
     }  
       
     if(c1.minute < 0)  
     {  
         c1.minute =60 + c1.minute;  
           
         c1.hour = c1.hour -1;  
     }  
       
     if(c1.hour < 0)  
     {  
         c1.hour = 24 + c1.hour;  
     }  
       
     return c1;  
 }  
   
 CTime CTime::operator +(int s)  
 {  
     CTime c1;  
       
     c1.hour = hour;  
       
     c1.minute = minute;  
       
     c1.second = second + s;  
       
     if(c1.second >= 60)  
     {     
         c1.minute = c1.minute + (c1.second / 60);  
           
         c1.second = c1.second % 60;           
     }  
       
     if(c1.minute >= 60)  
     {  
         c1.hour = c1.hour + (c1.minute / 60);  
           
         c1.minute = c1.minute % 60;  
     }  
       
     if(c1.hour >= 24)  
     {  
         c1.hour = c1.hour % 24;  
     }  
       
     return c1;  
 }  
   
 CTime CTime::operator -(int s)  
 {  
     CTime c1;  
       
     c1.hour = hour;  
       
     c1.minute = minute;  
       
     c1.second = second - s;  
       
     if(c1.second < 0)  
     {     
         c1.minute = c1.minute - 1 - (-c1.second / 60);  
           
         c1.second = 60 + c1.second % 60;              
     }  
       
     if(c1.minute < 0)  
     {  
         c1.hour = c1.hour - 1 - (-c1.minute / 60);  
           
         c1.minute = 60 + c1.minute % 60;  
     }  
       
     if(c1.hour < 0)  
     {  
         c1.hour = 24 + c1.hour;  
     }  
       
     return c1;  
 }  
   
 CTime CTime::operator ++(int)//定义后置自增运算符 "++"重载函数  
 {  
     CTime temp(* this);  
       
     second ++;  
       
     if(second >= 60)  
     {  
         second = second -60;  
           
         ++ minute;  
     }  
     if(minute >= 60)  
     {  
         minute = minute - 60;  
           
         ++ hour;  
     }  
     if(hour >= 24)  
     {  
         hour = hour - 24;  
     }  
       
     return temp;  
 }  
   
 CTime CTime::operator ++()//定义前置自增运算符"++"重载函数  
 {  
     if(++ second >= 60)  
     {  
         second = second -60;  
           
         ++ minute;  
           
         if(minute >= 60)  
         {  
             minute = minute -60;  
               
             ++ hour;  
               
             if(hour >= 24)  
             {  
                 hour = hour - 24;  
             }  
         }  
     }  
       
       
     return * this;  
 }  
   
 CTime CTime::operator --(int)//定义后置自增运算符 "--"重载函数  
 {  
     CTime temp(* this);  
       
     second --;  
       
     if(second <= 0)  
     {  
         second = 60 + second;  
           
         -- minute;  
     }  
       
     return temp;  
 }  
   
 CTime CTime::operator --()//定义前置自增运算符"--"重载函数  
 {  
     if(-- second <= 0)  
     {  
         second = 60 + second;  
           
         -- minute;  
     }  
       
     return * this;  
 }  
   
 CTime CTime::operator +=(CTime &c)  
 {  
       
       
     hour = hour + c.hour;  
       
     minute = minute + c.minute;  
       
     second = second + c.second;  
       
     if(second >= 60)  
     {  
         second = second - 60;  
           
         minute = minute + 1;  
     }  
       
     if(minute >= 60)  
     {  
         minute = minute - 60;  
           
         hour = hour + 1;  
     }  
       
     if(hour >= 24)  
     {  
         hour = hour -24;  
     }  
       
     return * this;//从定义前置"++" 来的灵感··int  
 }  
   
 CTime CTime::operator -=(CTime &c)  
 {     
     hour = hour - c.hour;  
       
     minute = minute - c.minute;  
       
     second = second - c.second;  
       
     if(second < 0)  
     {  
         second = 60 + second;  
           
         minute = minute - 1;  
     }  
       
     if(minute < 0)  
     {  
         minute =60 + minute;  
           
         hour = hour -1;  
     }  
       
     if(hour < 0)  
     {  
         hour = 24 + hour;  
     }  
       
     return * this;  
 }  
   
 CTime CTime::operator +=(int s)  
 {  
     hour = hour;  
       
     minute = minute;  
       
     second = second + s;  
       
     if(second >= 60)  
     {     
         minute = minute + (second / 60);  
           
         second = second % 60;             
     }  
       
     if(minute >= 60)  
     {  
         hour = hour + (minute / 60);  
           
         minute = minute % 60;  
     }  
       
     if(hour >= 24)  
     {  
         hour = hour % 24;  
     }  
       
     return * this;  
 }  
   
 CTime CTime::operator -=(int s)  
 {  
     hour = hour;  
       
     minute = minute;  
       
     second = second - s;  
       
     if(second < 0)  
     {     
         minute = minute - 1 - (-second / 60);  
           
         second = 60 + second % 60;            
     }  
       
     if(minute < 0)  
     {  
         hour = hour - 1 - (-minute / 60);  
           
         minute = 60 + minute % 60;  
     }  
       
     if(hour < 0)  
     {  
         hour = 24 + hour;  
     }  
       
     return * this;  
 }  
   
 main()  
 {  
     CTime c1(13, 13, 13),  
         c2(13, 13, 13),   
         c3(15, 15, 15),   
         c4(15, 15, 15),   
         c5(11, 47, 13),  
         c6, c7, c8,  
         c9(12,59,59),   
         c10(12, 59, 59),  
         c11(14, 14, 14),   
         c12(10, 46, 46),  
         c13(12, 23, 34),   
         c14(12, 23, 32),  
         c15(21, 32, 42),  
         c16(14, 15, 16);  
       
     cout <<"c1 = ";  
       
     c1.display();  
       
     cout << "c2 = ";  
       
     c2.display();  
       
     cout << "c3 = ";  
       
     c3.display();  
       
     cout << "c4 = ";  
       
     c4.display();  
       
     cout << "c5 = ";  
       
     c5.display();  
       
     cout << "c1 > c2" << (c1.operator >(c2)?" 成立":" 不成立") << endl;  
       
     cout << "c3 < c4" << (c3.operator <(c4)?" 成立":" 不成立") << endl;  
       
     cout << "c1 >= c2" << (c1.operator >=(c2)?" 成立":" 不成立") << endl;  
       
     cout << "c1 <= c2" << (c1.operator <=(c2)?" 成立":" 不成立") << endl;  
       
     cout << "c1 == c2" << (c1.operator ==(c2)?" 成立":" 不成立") << endl;  
       
     cout << "c3 != c4" << (c3.operator !=(c4)?" 成立":" 不成立") << endl;  
       
     c6 = c1 + c5;  
       
     cout << "c1 + c5 = ";  
       
     c6.display();  
       
     c7 = c1 - c5;  
       
     cout << "c1 - c5 = ";  
       
     c7.display();  
       
     c8 = c1 - 240;  
       
     cout << "c1 - 240 = ";  
       
     c8.display();  
       
     cout << "c9 = ";  
       
     c9.display();  
       
     c9  ++;  
       
     cout << "c9++ = ";  
       
     c9.display();  
       
     cout << "c10 = ";  
       
     c10.display();  
       
     ++ c10;  
       
     cout << "++c10 = ";  
       
     c10.display();  
       
     cout << "c11 = ";  
       
     c11.display();  
       
     cout << "c12 = ";  
       
     c12.display();  
       
     c11 += c12;  
       
     cout << "(c11 += c12) = ";  
       
     c11.display();  
       
     cout << "c13 = ";  
       
     c13.display();  
       
     cout << "c14 = ";  
       
     c14.display();  
       
     c13 -= c14;  
       
     cout << "(c13 -= c14) = ";  
       
     c13.display();  
       
     cout << "c15 = ";  
       
     c15.display();  
       
     cout << "c16 = ";  
       
     c16.display();  
       
     c15 += 18;  
       
     cout<< "(c15 += 18) = ";  
       
     c15.display();  
       
     c16 -= 16;  
       
     cout << "(c16 -= 16) = ";  
       
     c16.display();  
       
     system("pause");  
       
     return 0;  
 }  