pastebin

phanso
  1. #include <iostream>
  2. #include <cmath>
  3. ////        chua nap chong duoc >= cua hon so
  4. using namespace std;
  5.  
  6. //////////////           class phan so ////////////////////
  7. class phanso
  8. {
  9.         public:
  10.                 int tu;
  11.                 int mau;
  12.         public:
  13.                 phanso();
  14.                 phanso(int t,int m);
  15.                 phanso(phanso &p);
  16.                 ~phanso();
  17.                 int UCLN(int a,int b);
  18.                 phanso rutgon(phanso &p);
  19.                 bool operator >=(phanso p);
  20.                 void init(phanso &ps);
  21.                 friend istream &operator >>(istream &input,phanso &p)
  22.                 {
  23.                         cout << "moi nhap tu so:";
  24.                         input >> p.tu;
  25.                         cout << "moi nhap mau so:";
  26.                         input >> p.mau;
  27.                         p = p.rutgon(p);
  28.                         return input;
  29.                 }
  30.                 friend ostream &operator <<(ostream &output,phanso &p)
  31.                 {
  32.                         output << "tu so la:" << p.tu << "\n";
  33.                         output << "mau so la:" << p.mau << "\n";
  34.                         return output;
  35.                 }
  36. };
  37. void phanso::init(phanso &ps)
  38. {
  39.         cin >> ps;
  40. }
  41. phanso::phanso()
  42. {
  43.         tu = 0;
  44.         mau = 1;
  45. }
  46. phanso::phanso(int t,int m)
  47. {
  48.         tu = t;
  49.         mau = m;
  50. }
  51. phanso::phanso(phanso &p)
  52. {
  53.         this->tu = p.tu;
  54.         this->mau = p.mau;
  55. }
  56. phanso::~phanso()
  57. {
  58.         tu = 0;
  59.         mau = 1;
  60. }
  61. phanso phanso::rutgon(phanso &p)
  62. {
  63.         //kt mau khac 0 chua va yeu cau nhap lai
  64.         while(p.mau == 0)
  65.         {
  66.                 cout <<"moi nhap lai mau so:";
  67.                 cin >> p.mau;
  68.         }
  69.         //chuyen dau - ve tu hoac xoa 2 dau - o tu va mau
  70.         if(p.mau < 0 && p.tu < 0)
  71.         {
  72.                 p.mau = abs(p.mau);
  73.                 p.tu = abs(p.tu);
  74.         }
  75.         else if(p.mau < 0 && p.tu > 0)
  76.         {
  77.                 p.mau = abs(p.mau);
  78.                 p.tu = (-1)*p.tu;
  79.         }
  80.          //phan dung de rut gon phan so
  81.         int a = UCLN(p.tu,p.mau);
  82.         p.tu = p.tu/a;
  83.         p.mau = p.mau/a;
  84.         if(p.tu == p.mau)
  85.         {
  86.                 p.tu = 1;
  87.                 p.mau = 1;
  88.         }
  89.         return p;
  90. }
  91. int phanso::UCLN(int a,int b)
  92. {
  93.         a=abs(a);
  94.         b=abs(b);
  95.         while(a!=b)
  96.         {
  97.                 if(a>b)
  98.                         a=a-b;
  99.                 else
  100.                         b=b-a;
  101.         }
  102.         return a;
  103. }
  104. bool phanso::operator >= (phanso p)
  105. {
  106.         if(p.mau != this->mau)
  107.         {
  108.                 p.mau = p.mau * this->mau;
  109.                 this->mau = this->mau * p.mau;
  110.                 p.tu = p.tu * this->mau;
  111.                 this->tu = this->tu * p.mau;
  112.                 if(p.tu >= this->tu)
  113.                         return false;
  114.                 else
  115.                         return true;
  116.         }
  117.         else
  118.         {
  119.                 if(p.tu >= this->tu)
  120.                         return false;
  121.                 else
  122.                         return true;
  123.         }
  124. }
  125.  
  126.  
  127. ///////////////    class hon so         ///////////
  128. class honso: public phanso
  129. {
  130.         private:
  131.                 int pnguyen;
  132.         // constructors and destructors
  133.         public:
  134.                 honso();
  135.                 honso(int nguyen);
  136.                 honso(honso &hs);
  137.                 ~honso();
  138.         public:
  139.                 // phuong thuc de dieu chinh lai hon so sau khi khoi tao
  140.                 honso chuan_hon_so(honso &hs);
  141.                 // ham chuyen tu hon so thanh phan so
  142.                 phanso charge(honso hs);
  143.                 // phuong thuc so sanh >=
  144.                 bool operator >= (honso hs);
  145.                 friend istream &operator >> (istream &input,honso &hs)
  146.                 {
  147.                         cout << "moi nhap phan nguyen:";
  148.                         input >> hs.pnguyen;
  149.                         cout << "\n" << "moi nhap tu:";
  150.                         input >> hs.tu;
  151.                         cout << "\n" << "moi nhap mau:";
  152.                         input >> hs.mau;
  153.                         hs.rutgon(hs);
  154.                         hs.chuan_hon_so(hs);
  155.                         return input;
  156.                 }
  157.                 friend ostream &operator << (ostream &output,honso &hs)
  158.                 {
  159.                         cout << "phan nguyen la:";
  160.                         output << hs.pnguyen;
  161.                         cout << "\n" << " tu so la:";
  162.                         output << hs.tu;
  163.                         cout << "\n" << " mau so la:";
  164.                         output << hs.mau;
  165.                         return output;
  166.                 }
  167. };
  168. phanso honso::charge(honso hs)
  169. {
  170.         phanso ps;
  171.         ps.tu = abs(hs.pnguyen)*hs.mau+hs.tu;
  172.         ps.mau = hs.mau;
  173.         return ps;
  174. }
  175. bool honso::operator >= (honso hs)
  176. {
  177.         phanso ps = this->charge(this);
  178.         phanso ps1 = hs.charge(hs);
  179.         return (ps >= ps1);
  180. }
  181. honso honso::chuan_hon_so(honso &hs)
  182. {
  183.         if(hs.pnguyen < 0 && hs.tu < 0)
  184.         {
  185.                 hs.pnguyen = abs(hs.pnguyen);
  186.                 hs.tu = abs(hs.tu);
  187.         }
  188.         else if(hs.pnguyen > 0 && hs.tu <0)
  189.         {
  190.                 hs.tu = abs(hs.tu);
  191.                 hs.pnguyen = (-1)*hs.pnguyen;          
  192.         }
  193.         if(hs.tu == hs.mau)
  194.         {
  195.                 if(hs.pnguyen < 0)
  196.                         hs.pnguyen = (-1)+ hs.pnguyen;
  197.                 else
  198.                         hs.pnguyen = 1 + hs.pnguyen;
  199.                 hs.tu = 0;
  200.                 hs.mau = 1;
  201.         }
  202.         if(hs.mau == 1)
  203.         {
  204.                 if(hs.pnguyen < 0)
  205.                         hs.pnguyen = -hs.tu + hs.pnguyen;
  206.                 else
  207.                         hs.pnguyen = hs.tu + hs.pnguyen;
  208.                 hs.tu = 0;
  209.                 hs.mau = 1;     
  210.         }
  211.        
  212.         return hs;
  213. }
  214. honso::honso()
  215. {
  216.         pnguyen = 0;
  217. }
  218. honso::~honso()
  219. {
  220.         pnguyen = 0;
  221. }
  222. honso::honso(honso &hs)
  223. {
  224.         this->pnguyen = hs.pnguyen;
  225. }
  226. honso::honso(int nguyen)
  227. {
  228.         pnguyen = nguyen;
  229. }
  230.  
  231.  
  232. //////////////            MAIN         ////////////
  233. int main()
  234. {
  235. //      honso hs.hs1;
  236. //      cin >> hs >> hs1;
  237. //      cout << hs << hs1;
  238.         phanso ps,ps1;
  239.         cin >> ps >> ps1;
  240.         cout << ps << ps1;
  241.         cout << (ps >= ps1);
  242.         return 0;
  243. }
Parsed in 0.042 seconds