Facebook
From Mature Tapir, 2 Months ago, written in Plain Text.
Embed
Download Paste or View Raw
Hits: 58
  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include <iostream>
  4.  
  5. using namespace std;
  6.  
  7. class wiersz {
  8.         char * _wiersz;
  9.  
  10. public:
  11.         wiersz():_wiersz(NULL){}
  12.  
  13.         wiersz(char * ciag)
  14.         {
  15.                 this->_wiersz = new char[strlen(ciag)]; //alokacja pamiÄ™ci
  16.                 strcpy(this->_wiersz, ciag);    //skopiowanie danych
  17.         }
  18.  
  19.         wiersz&operator=(const wiersz &w)       //konstruktor kopiujÄ…cy
  20.         {
  21.                 this->_wiersz = new char[strlen(w._wiersz)];
  22.                 strcpy(this->_wiersz, w._wiersz);
  23.  
  24.                 return *this;
  25.         }
  26.  
  27. };
  28.  
  29.  
  30. struct wezel {
  31.         wiersz * dane;
  32.         wezel *pNext;
  33. };
  34.  
  35.  
  36.  
  37. class tekst {
  38.  
  39. protected:
  40.         wezel * pHead;
  41.  
  42. public:
  43.  
  44.         tekst() //konstruktor bezargumentowy
  45.         {
  46.                 pHead = nullptr;
  47.         }
  48.  
  49.         tekst(tekst &t)//kostruktor kopiujÄ…cy
  50.         {
  51.                 if (!t.pHead)
  52.                 {
  53.                         this->pHead = NULL;
  54.                         return;
  55.                 }
  56.  
  57.                 wezel * iterator_this = this->pHead;    //iterator po liÅ›cie obiektu, do którego bÄ™dÄ… wstawiane dane
  58.                 wezel * iterator_t = t.pHead;           //iterator po liÅ›cie obiektu kopiowanego
  59.  
  60.                 while (iterator_t != nullptr)   //dopóki nie skoÅ„czy siÄ™ lista kopiowana wstawianie obiektów do nowej listy
  61.                 {
  62.                         wezel *tmp = new wezel;         //alokacja pamiÄ™ci dla nowego wÄ™zÅ‚a
  63.                         tmp->dane = iterator_t->dane;   //przypisanie danych                   
  64.                         iterator_this = tmp;    //przypisanie do listy
  65.                         iterator_this = iterator_this->pNext;
  66.                         iterator_t = iterator_t->pNext;
  67.                 }
  68.         }
  69.  
  70.  
  71.  
  72.         tekst & operator=(tekst & t)
  73.         {
  74.                 if (this->pHead)        //jeżeli lista nie jest pusta to jest usuwana
  75.                 {
  76.                         wezel * iterator_this = this->pHead;
  77.  
  78.                         while (iterator_this != nullptr)
  79.                         {
  80.                                 wezel * tmp = iterator_this;
  81.                                 iterator_this = iterator_this->pNext;
  82.                                 delete tmp;
  83.                         }
  84.                 }
  85.  
  86.                 if (t.pHead == nullptr) //jeżeli lista jest pusta to przypisanie nullptr
  87.                 {
  88.                         this->pHead = nullptr;
  89.                         return *this;
  90.                 }
  91.  
  92.                 wezel *iterator_this = this->pHead;
  93.                 wezel *iterator_t = t.pHead;
  94.  
  95.                 while (iterator_t)
  96.                 {
  97.                         wezel *tmp = new wezel;         //alokacja pamiÄ™ci dla nowego wÄ™zÅ‚a
  98.                         tmp->dane = iterator_t->dane;   //przypisanie danych                   
  99.                         iterator_this = tmp;    //przypisanie do listy
  100.                         iterator_this = iterator_this->pNext;
  101.                         iterator_t = iterator_t->pNext;
  102.                 }
  103.  
  104.  
  105.                 return *this;
  106.         }
  107.  
  108.         void operator<<(const wiersz & w)
  109.         {
  110.                 wezel * iterator_this = this->pHead;    //iterator
  111.                 while (iterator_this)
  112.                 {
  113.                         iterator_this = iterator_this->pNext;   //przejÅ›cie do koÅ„ca listy
  114.                 }
  115.  
  116.                 iterator_this = new wezel;
  117.                 iterator_this->pNext = nullptr;
  118.                 iterator_this->dane = new wiersz;       //alokcja pamiÄ™ci
  119.                 *iterator_this->dane = w;       //przypisanie danych
  120.         }
  121.        
  122. };
  123.  
  124.  
  125. class edytor_tekstu :
  126.         public tekst
  127. {
  128.         unsigned numer_wiersza_aktualnego;
  129.  
  130.         edytor_tekstu(tekst &t) :tekst(t), numer_wiersza_aktualnego(0) {}       //konstruktor zawierajÄ…cy dodatkowo konstruktor kopiujÄ…cy
  131.  
  132.         operator int()
  133.         {
  134.                 int licznik_wierszy = 0;
  135.  
  136.                 wezel * iterator_this = this->pHead;   
  137.  
  138.                 while (iterator_this)   //zliczanie kolejnych wierszy
  139.                 {
  140.                         licznik_wierszy++;
  141.                         iterator_this = iterator_this->pNext;
  142.                 }
  143.  
  144.                 return licznik_wierszy;
  145.         }
  146.  
  147.  
  148.         void operator--()
  149.         {
  150.                 if (this->pHead == nullptr)
  151.                         throw exception("Lista jest pusta! ");
  152.                
  153.                 if (this->pHead->pNext == nullptr)      //jeżeli w liÅ›cie jest tylko jeden element to usuwanie tylko go
  154.                 {
  155.                         delete this->pHead;
  156.                         this->pHead = nullptr;
  157.                 }
  158.  
  159.                 int i = 0;
  160.  
  161.                 wezel * iterator_this = this->pHead->pNext;
  162.  
  163.                 wezel * previous_node = this->pHead;
  164.  
  165.                 while (i != numer_wiersza_aktualnego)   //dopóki nie przejdzie do aktualnego wiersza iterowanie po liÅ›cie
  166.                 {
  167.                         iterator_this = iterator_this->pNext;
  168.                         previous_node = previous_node->pNext;
  169.                 }
  170.  
  171.                 wezel * tmp = iterator_this;
  172.  
  173.                 previous_node->pNext = iterator_this->pNext;    //przepiÄ™cie wskaźnika w celu wykluczenia z listy elementu
  174.  
  175.                 delete tmp;     //usuniÄ™cie elementu
  176.         }
  177.  
  178.  
  179.         edytor_tekstu copy(int ile_wierszy)
  180.         {
  181.                 tekst t;
  182.                 edytor_tekstu tmp(t);   //nowy obiekt
  183.  
  184.                 int i = 0;
  185.  
  186.                 wezel * iterator_this = this->pHead;
  187.  
  188.                 int ii = 0;
  189.  
  190.                 while (ii < numer_wiersza_aktualnego)   //dotarcie do aktualnego wiersza
  191.                         iterator_this = iterator_this->pNext;
  192.  
  193.                 while (i != ile_wierszy || iterator_this != nullptr )
  194.                 {
  195.                         tmp << *iterator_this->dane;    //wczytanie kolejnych wierszy
  196.  
  197.                         i++;                                                    //przejÅ›cie do kolejnych iteracji
  198.                         iterator_this = iterator_this->pNext;
  199.                 }
  200.  
  201.         }
  202.  
  203.         ~edytor_tekstu()
  204.         {
  205.                 if (this->pHead)        //usuniÄ™cie listy
  206.                 {
  207.                         wezel * iterator_this = this->pHead;
  208.  
  209.                         while (iterator_this != nullptr)
  210.                         {
  211.                                 wezel * tmp = iterator_this;
  212.                                 iterator_this = iterator_this->pNext;
  213.                                 delete tmp;
  214.                         }
  215.                 }
  216.         }
  217.        
  218. };
  219.  
  220.  
  221.  
  222. int main() {
  223.        
  224.         return 0; }