daily pastebin goal
38%
SHARE
TWEET

Untitled

a guest Mar 20th, 2017 55 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2.  
  3. using namespace std;
  4. /*
  5.   Definicja typu wyliczeniowego "Symbol" dla symboli e, a, b, c, d.
  6. */
  7. enum Symbol{ e,a,b,c,d,k=-1 };
  8. Symbol TabSymboli[5]={e,a,b,c,d};
  9. Symbol Przeciwny(Symbol y); //deklaracja funkcji
  10. /**********************/
  11. /** DEFINICJE TABLIC **/
  12. /**********************/
  13. Symbol TablicaDodawania[5][5] = { { e,a,b,c,d },
  14.                                   { a,d,e,b,c },
  15.                                   { b,e,c,d,a },
  16.                                   { c,b,d,a,e },
  17.                                   { d,c,a,e,b } };
  18.  
  19. Symbol TablicaMnozen[5][5] ={ { e,e,e,e,e },
  20.                               { e,a,b,c,d },
  21.                               { e,b,a,d,c },
  22.                               { e,c,d,b,a },
  23.                               { e,d,c,a,b } };
  24.  
  25.  
  26.  
  27. /***************/
  28. /** DODAWANIE **/
  29. /***************/
  30. Symbol Dodaj(Symbol y, Symbol x) //Funkcja typu symbol obsługująca dodawanie symboli
  31. {
  32.     return TablicaDodawania[y][x];
  33. }
  34. Symbol operator + ( Symbol y, Symbol x) //przeciazenie operator dodawania
  35. {
  36.   return TablicaDodawania[y][x];
  37. }
  38. /**************/
  39. /** MNOZENIE **/
  40. /**************/
  41. Symbol Mnoz(Symbol y, Symbol x) //Funkcja typu symbol obsługująca mnozenie symboli
  42. {
  43.     return TablicaMnozen[y][x];
  44. }
  45. Symbol operator * (Symbol y, Symbol x) //przeciazenie operator mnozenia
  46. {
  47.     return TablicaMnozen[y][x];
  48. }
  49. /*****************/
  50. /** ODEJMOWANIE **/
  51. /*****************/
  52. Symbol Odejmij(Symbol y, Symbol x) //Funkcja typu symbol obsługująca odejmowanie symboli
  53. {
  54.   x=Przeciwny(x);
  55.   return TablicaDodawania[y][x];
  56. }
  57.  
  58. Symbol operator - (Symbol y, Symbol x) //przeciazenie operator odejmowania
  59. {
  60.   x=Przeciwny(x);
  61.   return TablicaDodawania[y][x];
  62. }
  63.  
  64. /***************/
  65. /** DZIELENIE **/
  66. /***************/
  67. Symbol Dziel(Symbol y, Symbol x) //Funkcja typu symbol obsługująca dzielenie symboli
  68. {
  69.  
  70.  x=Przeciwny(x);
  71.   return TablicaMnozen[y][x];
  72. }
  73.  
  74. Symbol operator / (Symbol y, Symbol x) //przeciazenie operator dzielenia
  75. {
  76.   x=Przeciwny(x);
  77.   return TablicaMnozen[y][x];
  78. }
  79.  
  80. /*****************/
  81. /** POTEGOWANIE **/
  82. /*****************/
  83. Symbol Poteguj (Symbol y, int n) //Funkcja typu symbol obsługująca potegowanie symboli
  84. {
  85.     Symbol wynik = y;
  86.     if (n <= 0)
  87.     {
  88.         cout << "Bledna wartosc potegi" << endl;
  89.         return e;
  90.     }
  91.     else
  92.     {
  93.         for (int i=1; i<n; i++)
  94.         {
  95.             wynik = Mnoz (y, wynik);
  96.         }
  97.     }
  98.     return wynik;
  99. }
  100.  
  101. operator ^ (Symbol y, int n) //przeciazenie operator potegowania
  102. {
  103.     return Poteguj (y, n);
  104. }
  105.  
  106. /********************************/
  107. /** ZAMIANA NA PRZECIWY SYMBOL **/
  108. /********************************/
  109. Symbol Przeciwny(Symbol y)  // algorytm zamieniania znaku na przeciwny ( to działa tak wysylamy Znak do funkcji i szukamy drugiego znaku dla ktorego ich suma rowna sie E, i zwracamy drugi znak )
  110. {
  111.   Symbol tymczasowy; //tworzy tymczasowa zmienna do porownywania wartosci
  112.   for (int i=0; i<5; i++) //wykonaj sie 5 razy
  113.     {
  114.       tymczasowy=Dodaj(y,TabSymboli[i]); //Jezeli Suma znaku wprowadzonego i ktoregokolwiek z tablicy bedzie rowna E to znaczy ze ten znak jest znakiem przeciwnym
  115.       if(tymczasowy==e) return TabSymboli[i]; //zwraca symbol przeciwny jesli znalazlo
  116.     }
  117.   return e;
  118. }
  119.  
  120. /***********************/
  121. /** WCZYTANIE SYMBOLU **/
  122. /***********************/
  123.  
  124. bool WczytajSymbol(Symbol & x) //Wewnatrz funkcji wprowadzamy znak i sprawdzamy czy nalezy do TablicyCharow jezeli tak to przypisujemy ten znak, do zmiennej X typu Symbol
  125. {
  126.   char znak;
  127.   char TabCharow[5]={ 'e','a','b','c','d'}; //tablicaCharow identyczna jak tablicaSymboli
  128.   cin>>znak; // wprowadz znak typu char
  129.   for (int i=0; i<5; i++) //  wykonaj sie 5 razy, przejdz po calej tablicy charow
  130.     {
  131.       if( znak==TabCharow[i]) //jezeli wprowadzony znak jest w tablicy to przypisz do X ten znak ale typu Symbol
  132.         {
  133.         x=TabSymboli[i]; //przypisanie do X wprowadzonego znaku ale typu Symbol
  134.         return true;
  135.         }
  136.      }
  137.     return false;
  138. }
  139.  
  140. /************************/
  141. /** POROWNANIE WYNIKOW **/
  142. /************************/
  143.  
  144. void Porownaj(Symbol wynik_alg, Symbol wynik_ope, Symbol wynik_fun)
  145. {
  146.     if(wynik_alg == wynik_fun) cout << "Wyniki wyrazanie algebraicznego i funkcyjnego Identyczne= " << wynik_alg <<endl;
  147.     else
  148.         cout <<"Wyniki Rozne, Wynik_alg= "<<wynik_alg<<" Wynik_fun= "<<wynik_fun<<endl;
  149.     if(wynik_ope == wynik_fun) cout << "Wyniki wyrazanie operatorowego i funkcyjnego Identyczne= " << wynik_ope <<endl;
  150.     else
  151.         cout <<"Wyniki Rozne, Wynik_ope "<<wynik_ope<<" Wynik_fun= "<<wynik_fun<<endl;
  152.     if(wynik_ope == wynik_alg) cout << "Wyniki wyrazanie operatorowego i algebraicznego Identyczne= " << wynik_ope <<endl;
  153.     else
  154.         cout <<"Wyniki Rozne, Wynik_alg "<<wynik_ope<<" Wynik_fun= "<<wynik_alg<<endl;
  155. }
  156.  
  157. /**************************************/
  158. /**  Definicje przeciazen operatorow **/
  159. /**************************************/
  160.  
  161. Symbol operator -(Symbol y)
  162. {
  163.   y=Przeciwny(y);
  164.   return y;
  165. }
  166.  
  167. /*Symbol operator /(Symbol y)
  168. {
  169.   y=Przeciwny(y);
  170.   return y;
  171.   }*/
  172. Symbol operator +(Symbol y)
  173. {
  174.   return y;
  175. }
  176.  
  177. Symbol operator *(Symbol y)
  178. {
  179.   return y;
  180. }
  181. /*****************************************************/
  182.  
  183.  
  184.  
  185. int main()
  186. {
  187.   Symbol x=b, wynik;
  188.   Symbol wynik_alg, wynik_ope, wynik_fun;
  189.  
  190.  cout << operator ^ (x,3) ;
  191.  
  192.  
  193.  
  194.     /* wynik_alg=y*x;
  195.     wynik_fun=Mnoz(y,x);
  196.     wynik_ope= operator * (y,x);
  197.     cout << " przeprowadzam porownanie dla operacji Mnozenia "<<endl;
  198.     Porownaj(wynik_alg,wynik_fun,wynik_ope);
  199.     */
  200.  
  201. }
RAW Paste Data
Top