daily pastebin goal
43%
SHARE
TWEET

l_j_wzorzec

wilk_maciej Apr 16th, 2018 (edited) 60 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. #include <stdio.h>
  3. using namespace std;
  4.  
  5. // OBIEKT LISTA                                                                                                             DONE
  6. // operator wejscia dodaje 1 element, wyjscia wypisuje wszystkie el     DONE
  7. // konstruktor, destruktor, konstruktor kopiujący                                          DONE
  8. // + do listy dopisuje na końcu drógą                                                                    DONE
  9. // =, ==, !=                                                                                                                    DONE
  10. template<typename T>
  11. class List;
  12.  
  13. template<typename T>
  14. class Element;
  15.  
  16. class Macierze{
  17.   friend ostream & operator<< (ostream & s1, Macierze & o1);
  18.   friend istream & operator>>(istream & s1, Macierze & o1);
  19.    
  20.  
  21.   double *ws;
  22.   int rozmiar;
  23.   public:
  24.    
  25.   Macierze(){
  26.     ws=NULL;
  27.   }
  28.   Macierze(int rozm, int wart){
  29.     rozmiar = rozm;
  30.     ws = new double[rozm*rozm];
  31.     for ( int i = 0; i < rozmiar*rozmiar; i++){
  32.             ws[i] = wart;
  33.     }
  34.  
  35.   }
  36.  
  37.   Macierze(const Macierze &o1){  // kopiujacy konstruktor, potrzebny przy dodawaniu
  38.     rozmiar = o1.rozmiar;
  39.     ws = new double[o1.rozmiar*o1.rozmiar];
  40.     for ( int i = 0; i < rozmiar*rozmiar; i++){
  41.             ws[i] = o1.ws[i];
  42.     }
  43.     }
  44.  
  45.   ~Macierze(){
  46.     if (ws!=NULL){
  47.       delete [] ws;
  48.       ws=NULL;
  49.     }
  50.   }
  51.  
  52.     Macierze & operator=(const Macierze & o1){
  53. //zwolnić pamięć dla lewej str
  54. //zarezerwować pamieć
  55. //przepisać pamieć
  56.     if (this == &o1) return *this;
  57.     if (this->ws!=NULL){
  58.       delete [] this->ws;
  59.     }
  60.     this->rozmiar = o1.rozmiar;
  61.  
  62.     if (o1.rozmiar>0){
  63.           this->ws = new double[o1.rozmiar*o1.rozmiar];
  64.           for (int i=0;i<(o1.rozmiar*o1.rozmiar);i++){
  65.               this->ws[i] = o1.ws[i];
  66.           }
  67.     }
  68.  
  69.     return *this;
  70.     }
  71.  
  72.  
  73.     Macierze  operator+(const Macierze &o1){
  74.         Macierze wynik= Macierze(*this);
  75.         if (this->rozmiar != o1.rozmiar){
  76.             cout <<"Nie można dodać różnych macierzy!";
  77.             return wynik;
  78.         }
  79.         else{
  80.             for (int i=0;i< o1.rozmiar*o1.rozmiar; i++){
  81.                 wynik.ws[i] += o1.ws[i];
  82.             }
  83.             return wynik;
  84.         }
  85.  
  86.     }
  87.  
  88.     Macierze  operator-(const Macierze &o1){
  89.         Macierze wynik= Macierze(*this);
  90.         if (this->rozmiar != o1.rozmiar){
  91.             cout <<"nie można wykonać" <<endl;
  92.             return wynik;
  93.         }
  94.         else{
  95.             for (int i=0;i< o1.rozmiar*o1.rozmiar; i++){
  96.                 wynik.ws[i] -= o1.ws[i];
  97.             }
  98.         return wynik;
  99.  
  100.         }
  101.     }
  102.  
  103.     Macierze  operator*(const Macierze &o1){
  104. //działa tylko dla pierwszego wiersza
  105.         Macierze wynik= Macierze(o1.rozmiar, 0);
  106.         cout <<wynik <<endl;
  107.         if (this->rozmiar != o1.rozmiar){
  108.             cout <<"nie można wykonać" <<endl;
  109.             return wynik;
  110.         }
  111.         else{
  112.  
  113.  
  114.  
  115. /*            int count=0;
  116.             for (int i=0;i<o1.rozmiar*o1.rozmiar; i++){
  117.                 int k=0;
  118.                 int wynik_klatki=0;
  119.                 for (int j=i;j<=(o1.rozmiar*o1.rozmiar + count);j+=o1.rozmiar){
  120.                     wynik_klatki += o1.ws[k]*this->ws[j];
  121.                     k++;
  122.                 }
  123.                 count +=1;
  124.                 wynik.ws[i]=wynik_klatki;
  125. */
  126.             int n=o1.rozmiar;
  127.             for (int i=0; i<n*n;i+=n){
  128.                 for (int j=0; j<n;j++){
  129.                     for (int k=0; k<n;k++){
  130.                         cout<<i <<"=i  " <<i+j << "=i+j  XX ";
  131.                         wynik.ws[i+j]+=this->ws[k+i]*o1.ws[k*n+j];
  132.                     }
  133.                 cout <<endl;
  134.                 }
  135.             }
  136.            
  137.            
  138.         return wynik;
  139.  
  140.         }
  141.     }
  142.  
  143.  
  144.     int operator==(const Macierze &o1){
  145.         if (this->rozmiar != o1.rozmiar){
  146.             cout <<"Macierze różnych rozmiarów!" <<endl;
  147.             return 0;
  148.         }
  149.         else{
  150.             int flaga=0;
  151.             for(int i=0;i< o1.rozmiar*o1.rozmiar; i++){
  152.                 if(this->ws[i] == o1.ws[i]) flaga+=1;
  153.             }
  154.  
  155.             if(flaga==0) return 1;
  156.             else{
  157.                 return 0;
  158.             }
  159.         }
  160.     }
  161.  
  162.     int operator>=(const Macierze &o1){
  163. //operatory >= <= działają na zasadzie: zlicza sumę wszystkich elementów jednego i drugiego, a później porównuje te liczby
  164.         if (this->rozmiar != o1.rozmiar){
  165.             cout <<"Macierze różnych rozmiarów! Nie porównam" <<endl;
  166.             return 0;
  167.         }
  168.         else{
  169.             int suma1=0;
  170.             int suma2=0;
  171.             for(int i=0;i< this->rozmiar*this->rozmiar; i++){
  172.                 suma1+=this->ws[i];
  173.             }
  174.  
  175.             for(int i=0;i< o1.rozmiar*o1.rozmiar; i++){
  176.                 suma2+=o1.ws[i];
  177.             }
  178.  
  179.             if(suma1>=suma2) return 1;
  180.             else{
  181.                 return 0;
  182.             }
  183.         }
  184.     }
  185.  
  186.     int operator<=(const Macierze &o1){
  187.         if (this->rozmiar != o1.rozmiar){
  188.             cout <<"Macierze różnych rozmiarów! Nie porównam" <<endl;
  189.             return 0;
  190.         }
  191.         else{
  192.             int suma1=0;
  193.             int suma2=0;
  194.             for(int i=0;i< this->rozmiar*this->rozmiar; i++){
  195.                 suma1+=this->ws[i];
  196.             }
  197.  
  198.             for(int i=0;i< o1.rozmiar*o1.rozmiar; i++){
  199.                 suma2+=o1.ws[i];
  200.             }
  201.  
  202.             if(suma1<=suma2) return 1;
  203.             else{
  204.                 return 0;
  205.             }
  206.         }
  207.     }
  208.    
  209.     int operator!=(const Macierze &o1){
  210.         if (this->rozmiar != o1.rozmiar){
  211.             cout <<"Macierze różnych rozmiarów! Nie porównam" <<endl;
  212.             return 0;
  213.         }
  214.         else{
  215.             int roznica=0;
  216.             for(int i=0;i< this->rozmiar*this->rozmiar; i++){
  217.                 if (this->ws[i] != o1.ws[i])roznica+=1;
  218.             }
  219.  
  220.  
  221.             if(roznica!=0) return 1;
  222.             else{
  223.                 return 0;
  224.             }
  225.         }
  226.     }
  227.  
  228. //koniec klasy macierze
  229. };
  230.  
  231. ostream & operator<< (ostream & s1, Macierze & o1){
  232.   if (o1.ws!=NULL){
  233.       for(int i=0, j=1;i<(o1.rozmiar*o1.rozmiar);i++, j++){
  234.           cout << o1.ws[i] <<" " ;
  235.           if (j==o1.rozmiar){
  236.               s1<<endl;
  237.               j=0;
  238.           }
  239.       }
  240.   }
  241.   return s1;
  242. }
  243.  
  244. istream & operator>>(istream & s1, Macierze & o1){
  245.   s1>>o1.rozmiar;
  246.  
  247.   if (o1.rozmiar>0){
  248.       if (o1.ws!=NULL){
  249.           delete [] o1.ws;
  250.       }
  251.       o1.ws = new double[o1.rozmiar*o1.rozmiar];
  252.       for (int i=0;i<(o1.rozmiar*o1.rozmiar);i++){
  253.           cin >> o1.ws[i];
  254.       }
  255.   }
  256.   return s1;
  257. }
  258.  
  259.  
  260.  
  261. template<class T>
  262. class Element{
  263.  
  264.   template<class S>
  265.   friend class List;
  266.  
  267.   public:
  268.   T war;
  269.   class Element *next;
  270. };
  271.  
  272.  
  273. template<class T>
  274. class List{
  275.  
  276.   template<typename S>
  277.   friend ostream & operator << (ostream & s1, List<S> & o1);
  278.   template<typename S>
  279.   friend istream & operator >> (istream & s1, List<S> & o1);
  280.  
  281.  
  282.   class Element<T> *pierwszy;
  283.   public:
  284.   List<T>(){
  285.     pierwszy=NULL;
  286.   }
  287.  
  288.   List<T> (class List<T> &o1){
  289.     if (o1.pierwszy==NULL){
  290.       pierwszy=NULL;
  291.     }
  292.     else{
  293.       class Element<T> *nowy = new Element<T>;
  294.       nowy->war=o1.pierwszy->war;
  295.       Element<T> *i =o1.pierwszy;
  296.       Element<T> *poprz = nowy;
  297.       pierwszy=nowy;
  298.       i=i->next;
  299.       while (i!=NULL){
  300.         class Element<T> *elem = new Element<T>;
  301.         elem->war=i->war;
  302.         poprz->next=elem;
  303.         poprz=elem;
  304.         i=i->next;
  305.       }
  306.       poprz->next=NULL;
  307.     }
  308.   }
  309.  
  310.  
  311.  
  312.   ~List<T>(){
  313.     while (pierwszy!=NULL){
  314.       if (pierwszy->next != NULL){
  315.         class Element<T> *nowy=pierwszy->next;
  316.         delete pierwszy;
  317.         pierwszy = nowy;
  318.       }
  319.       else{
  320.         delete pierwszy;
  321.         pierwszy = NULL;
  322.       }
  323.     }
  324.   }
  325.  
  326.   List<T> & operator = (List<T> &o1)
  327.     {
  328.     if (this==&o1)
  329.       return *this;
  330.     else{
  331.     while (pierwszy!=NULL){
  332.       if (pierwszy->next != NULL){
  333.         class Element<T> *nowy=pierwszy->next;
  334.         delete pierwszy;
  335.         pierwszy = nowy;
  336.       }
  337.       else{
  338.         delete pierwszy;
  339.         pierwszy = NULL;
  340.       }
  341.     }
  342.     }
  343.     if (o1.pierwszy==NULL){
  344.       return *this;
  345.     }
  346.     else{
  347.       Element<T> *current = new Element<T>;
  348.       Element<T> *node;
  349.       Element<T> *wsk = o1.pierwszy;
  350.       current->war=wsk->war;
  351.       this->pierwszy=current;
  352.       while (wsk->next!=NULL)
  353.       {
  354.         node = new Element<T>;
  355.         current->next=node;
  356.         wsk=wsk->next;
  357.         node->war=wsk->war;
  358.         current=node;
  359.       }
  360.       return *this;
  361.     }
  362.   }
  363.  
  364.   friend List<T> & operator + (List<T> &o1, List<T> &o2){
  365.     static List temp;
  366.     if (o1.pierwszy==NULL && o2.pierwszy==NULL){
  367.       return temp;
  368.     }
  369.     else if (o1.pierwszy==NULL && o2.pierwszy != NULL){
  370.       temp=o2;
  371.       return temp;
  372.     }
  373.     else if (o1.pierwszy!=NULL && o2.pierwszy==NULL){
  374.       temp=o1;
  375.       return temp;
  376.     }
  377.  
  378.     Element<T> *current = new Element<T>;
  379.     Element<T> *node;
  380.     Element<T> *i = o1.pierwszy;
  381.     Element<T> *j = o2.pierwszy;
  382.     current->war=i->war;
  383.     temp.pierwszy=current;
  384.     while (i->next!=NULL)
  385.     {
  386.       node=new Element<T>;
  387.       current->next=node;
  388.       i=i->next;
  389.       node->war=i->war;
  390.       current=node;
  391.     }
  392.     node=new Element<T>;
  393.     node->war=j->war;
  394.     current->next=node;
  395.     while (j!=NULL)
  396.     {
  397.       node=new Element<T>;
  398.       current->next=node;
  399.       node->war=j->war;
  400.       current=node;
  401.       j=j->next;
  402.     }
  403.     return temp;
  404.   }
  405.  
  406.   int operator == (List<T> &o1){
  407.     if (this->pierwszy ==NULL && o1.pierwszy==NULL){
  408.       return true;
  409.     }
  410.     if (this->pierwszy ==NULL && o1.pierwszy!=NULL){
  411.       return false;
  412.     }
  413.  
  414.     if (o1.pierwszy!=NULL){
  415.       Element<T> *head=o1.pierwszy;
  416.       Element<T> *headthis=this->pierwszy;
  417.       while (head->next!=NULL)
  418.       {
  419.         if (head->war!=headthis->war)
  420.           return false;
  421.         head=head->next;
  422.         headthis=headthis->next;
  423.       }
  424.       return true;
  425.     }
  426.     else return false;
  427.   }
  428.  
  429.   bool operator != (List<T> &o1){
  430.     if (this->pierwszy==NULL && o1.pierwszy==NULL){
  431.       return false;
  432.     }
  433.  
  434.     else if (this->pierwszy ==NULL && o1.pierwszy!=NULL){
  435.       return true;
  436.     }
  437.  
  438.     else if (this->pierwszy !=NULL && o1.pierwszy==NULL){
  439.       return true;
  440.     }
  441.     else{
  442.       bool wynik;
  443.       Element<T> *head=o1.pierwszy;
  444.       Element<T> *headthis=this->pierwszy;
  445.       while (head->next!=NULL && headthis->next!=NULL)
  446.       {
  447.         if (head->war!=headthis->war)
  448.           wynik=true;
  449.         else{
  450.           wynik=false;
  451.           break;
  452.         }
  453.         head=head->next;
  454.         headthis=headthis->next;
  455.       }
  456.       if (head->next==NULL && headthis ->next!=NULL){
  457.         wynik=false;
  458.       }
  459.       return wynik;
  460.     }
  461.   }
  462. };
  463.  
  464.  
  465. //streamy się wysypują
  466.  
  467. template<class T>
  468. ostream & operator<< (ostream & s1, List<T> & o1){
  469.  
  470.   Element<T> *n = o1.pierwszy;
  471.   while(n){
  472.     s1 << n->war << " " ;
  473.     n = n->next;
  474.   }
  475.   cout << endl;
  476.   return s1;
  477. }
  478.  
  479.  
  480. template<class T>
  481. istream & operator >>(istream &s1, List<T> &o1){
  482.  
  483.   class Element<T> *element = new Element<T>;
  484.   cout <<"Podaj wartość elementu listy ";
  485.   s1 >> element->war;
  486.   if (o1.pierwszy==NULL){
  487.     o1.pierwszy=element;
  488.     o1.pierwszy->next=NULL;
  489.   }
  490.   else{
  491.   class Element<T> *wsk =o1.pierwszy;
  492.   while(wsk->next != NULL){
  493.     wsk=wsk->next;
  494.   }
  495.   wsk->next = element;
  496.   element->next = NULL;
  497.   }
  498.   return s1;
  499. }
  500.  
  501.  
  502. int main()
  503. {
  504.   List<int> o1, o2, o3;
  505.   cin >> o1;
  506.   cin >> o1;
  507.   cout << "Lista1: " <<o1;
  508.   cin >> o2;
  509.   o3=o1+o2;
  510.   cout <<"Lista 3 = 1+2: " << o3;
  511.  
  512.   List<Macierze> z1, z2, z3;
  513.   cin >> z1;
  514.   cin >> z1;
  515.   cout << "Lista macierzy 1: " <<endl << z1;
  516.   cin >> z2;
  517.   z3 = z2+z1;
  518.   cout <<"Suma list: "<< endl << z3;
  519.   return 0;
  520. }
  521. // sprawdzanie na 2 listach intach cin a x3, cin b x2 c=a+b
  522. // cout c, pózniej to samo na klasach: macierzy
  523. //
  524. // do porzeczytania:
  525. // dzielenie na pliki nagłówkowe
  526. // deklaracje wewnątrz, definicję na zewnątrz (chodzi o '::', np std::)
RAW Paste Data
Top