Facebook
From Unreliable Lechwe, 6 Years ago, written in Plain Text.
Embed
Download Paste or View Raw
Hits: 250
  1. #include "rzymskie.h"
  2. #include <string>
  3. #include <iostream>
  4. using namespace std;
  5. //___________________________________________________________________
  6. int wartoscR(char a)
  7. {
  8.         switch (a)
  9.         {
  10.         case 'M':
  11.                 return 1000;
  12.         case 'D':
  13.                 return 500;
  14.         case 'C':
  15.                 return 100;
  16.         case 'L':
  17.                 return 50;
  18.         case 'X':
  19.                 return 10;
  20.         case 'V':
  21.                 return 5;
  22.         case 'I':
  23.                 return 1;
  24.         }
  25.         return 0;
  26. }
  27. //___________________________________________________________________
  28. void rzymskie::setWartL(int a)
  29. {
  30.         wartoscL = a;
  31.         convertLnaC();
  32. }
  33. //___________________________________________________________________
  34. void rzymskie::setWartC(char a[N])
  35. {
  36.         strcpy_s(wartoscC, a);
  37.         convertCnaL();
  38. }
  39. //___________________________________________________________________
  40. rzymskie::rzymskie()
  41. {
  42.         cout << endl << "KONSTRUKTOR1" << endl;
  43. }
  44. //___________________________________________________________________
  45. rzymskie::rzymskie(int a):wartoscL(a)
  46. {
  47.         cout << endl << "KONSTRUKTOR2" << endl;
  48.         convertLnaC();
  49. }
  50. //___________________________________________________________________
  51. rzymskie::rzymskie(char a[N])
  52. {
  53.         cout << endl << "KONSTRUKTOR3" << endl;
  54.         strcpy_s(wartoscC, a);
  55.         convertCnaL();
  56. }
  57. //___________________________________________________________________
  58. rzymskie::~rzymskie()
  59. {
  60.         cout << endl << "DESTRUKTOR" << endl;
  61. }
  62. //___________________________________________________________________
  63. void rzymskie::convertCnaL()
  64. {
  65.         int a=wartoscR(wartoscC[0]), i = 1, pom;
  66.         while (wartoscC[i] != 0)
  67.         {
  68.                 pom = wartoscR(wartoscC[i]);
  69.                 i++;
  70.                 if (wartoscC == 0)
  71.                 {
  72.                         a += pom;
  73.                         wartoscL = a;
  74.                         return;
  75.                 }
  76.                 else if(wartoscR(wartoscC[i]) > pom)
  77.                 {
  78.                         a -= pom;
  79.                 }
  80.                 else
  81.                 {
  82.                         a += pom;
  83.                 }
  84.         }
  85.         wartoscL = a;
  86. }
  87. //___________________________________________________________________
  88. void rzymskie::convertLnaC()
  89. {
  90.         int pom = wartoscL/1000, i;
  91.         for (i = 0; i < pom; i++)
  92.                 wartoscC[i] = 'M';
  93.         pom = wartoscL % 1000 / 100;
  94.         switch (pom)
  95.         {
  96.         case 9:
  97.                 wartoscC[i] = 'C';
  98.                 wartoscC[i + 1] = 'M';
  99.                 i += 2;
  100.                 break;
  101.         case 8:
  102.                 wartoscC[i] = 'D';
  103.                 wartoscC[i + 1] = 'C';
  104.                 wartoscC[i + 2] = 'C';
  105.                 wartoscC[i + 3] = 'C';
  106.                 i += 4;
  107.                 break;
  108.         case 7:
  109.                 wartoscC[i] = 'D';
  110.                 wartoscC[i + 1] = 'C';
  111.                 wartoscC[i + 2] = 'C';
  112.                 i += 3;
  113.                 break;
  114.         case 6:
  115.                 wartoscC[i] = 'D';
  116.                 wartoscC[i + 1] = 'C';
  117.                 i += 2;
  118.                 break;
  119.         case 5:
  120.                 wartoscC[i] = 'D';
  121.                 i++;
  122.                 break;
  123.         case 4:
  124.                 wartoscC[i] = 'C';
  125.                 wartoscC[i + 1] = 'D';
  126.                 i += 2;
  127.                 break;
  128.         case 3:
  129.                 wartoscC[i] = 'C';
  130.                 wartoscC[i + 1] = 'C';
  131.                 wartoscC[i + 2] = 'C';
  132.                 i += 3;
  133.                 break;
  134.         case 2:
  135.                 wartoscC[i] = 'C';
  136.                 wartoscC[i + 1] = 'C';
  137.                 i += 2;
  138.                 break;
  139.         case 1:
  140.                 wartoscC[i] = 'C';
  141.                 i++;
  142.                 break;
  143.         }
  144.         pom = wartoscL % 100 / 10;
  145.         switch (pom)
  146.         {
  147.         case 9:
  148.                 wartoscC[i] = 'X';
  149.                 wartoscC[i + 1] = 'C';
  150.                 i += 2;
  151.                 break;
  152.         case 8:
  153.                 wartoscC[i] = 'L';
  154.                 wartoscC[i + 1] = 'X';
  155.                 wartoscC[i + 2] = 'X';
  156.                 wartoscC[i + 3] = 'X';
  157.                 i += 4;
  158.                 break;
  159.         case 7:
  160.                 wartoscC[i] = 'L';
  161.                 wartoscC[i + 1] = 'X';
  162.                 wartoscC[i + 2] = 'X';
  163.                 i += 3;
  164.                 break;
  165.         case 6:
  166.                 wartoscC[i] = 'L';
  167.                 wartoscC[i + 1] = 'X';
  168.                 i += 2;
  169.                 break;
  170.         case 5:
  171.                 wartoscC[i] = 'L';
  172.                 i++;
  173.                 break;
  174.         case 4:
  175.                 wartoscC[i] = 'X';
  176.                 wartoscC[i + 1] = 'L';
  177.                 i += 2;
  178.                 break;
  179.         case 3:
  180.                 wartoscC[i] = 'X';
  181.                 wartoscC[i + 1] = 'X';
  182.                 wartoscC[i + 2] = 'X';
  183.                 i += 3;
  184.                 break;
  185.         case 2:
  186.                 wartoscC[i] = 'X';
  187.                 wartoscC[i + 1] = 'X';
  188.                 i += 2;
  189.                 break;
  190.         case 1:
  191.                 wartoscC[i] = 'X';
  192.                 i++;
  193.                 break;
  194.         }
  195.         pom = wartoscL % 10;
  196.         switch (pom)
  197.         {
  198.         case 9:
  199.                 wartoscC[i] = 'I';
  200.                 wartoscC[i + 1] = 'X';
  201.                 i += 2;
  202.                 break;
  203.         case 8:
  204.                 wartoscC[i] = 'V';
  205.                 wartoscC[i + 1] = 'I';
  206.                 wartoscC[i + 2] = 'I';
  207.                 wartoscC[i + 3] = 'I';
  208.                 i += 4;
  209.                 break;
  210.         case 7:
  211.                 wartoscC[i] = 'V';
  212.                 wartoscC[i + 1] = 'I';
  213.                 wartoscC[i + 2] = 'I';
  214.                 i += 3;
  215.                 break;
  216.         case 6:
  217.                 wartoscC[i] = 'V';
  218.                 wartoscC[i + 1] = 'I';
  219.                 i += 2;
  220.                 break;
  221.         case 5:
  222.                 wartoscC[i] = 'V';
  223.                 i++;
  224.                 break;
  225.         case 4:
  226.                 wartoscC[i] = 'I';
  227.                 wartoscC[i + 1] = 'V';
  228.                 i += 2;
  229.                 break;
  230.         case 3:
  231.                 wartoscC[i] = 'I';
  232.                 wartoscC[i + 1] = 'I';
  233.                 wartoscC[i + 2] = 'I';
  234.                 i += 3;
  235.                 break;
  236.         case 2:
  237.                 wartoscC[i] = 'I';
  238.                 wartoscC[i + 1] = 'I';
  239.                 i += 2;
  240.                 break;
  241.         case 1:
  242.                 wartoscC[i] = 'I';
  243.                 i++;
  244.                 break;
  245.         }
  246.         wartoscC[i] = 0;
  247. }
  248. //___________________________________________________________________
  249. istream& operator>> (istream& in, rzymskie& a)
  250. {
  251.         char z;
  252.         cout << "1-int 2-char" << endl;
  253.         cin >> z;
  254.         if (z == '1')
  255.         {
  256.                 cout << "Podaj int" << endl;
  257.                 int b;
  258.                 cin >> b;
  259.                 a.setWartL(b);
  260.         }
  261.         else
  262.         {
  263.                 cout << "Podaj chary" << endl;
  264.                 char s[N];
  265.                 cin >> s;
  266.                 a.setWartC(s);
  267.         }
  268.         return in;
  269. }
  270. //___________________________________________________________________
  271. ostream& operator<< (ostream& out, const rzymskie& a)
  272. {
  273.         out << endl << "Liczba " << a.wartoscL << " w rzymskim " << a.wartoscC << endl;
  274.         return out;
  275. }