Facebook
From adam128pl@gmail.com, 6 Days ago, written in C++.
Embed
Download Paste or View Raw
Hits: 24
  1. // 3 kolos pk.cpp : Ten plik zawiera funkcj─Ö ÔÇ×mainÔÇŁ. W nim rozpoczyna si─Ö i ko┼äczy wykonywanie programu.
  2. //
  3.  
  4. #include "pch.h"
  5. #include <iostream>
  6. #include <math.h>
  7.  
  8. using namespace std;
  9.  
  10. class zespolona
  11. {
  12.         double rzecz,uroj;
  13. public:
  14.         zespolona() :rzecz(0), uroj(0) {};                                      //konstruktor
  15.         zespolona &operator +=(const zespolona &i)
  16.         {
  17.                 rzecz += i.rzecz;
  18.                 uroj += i.uroj;
  19.                 return *this;
  20.         }
  21.         bool operator>(const zespolona &i)
  22.         {
  23.                 if (sqrt(rzecz*rzecz + uroj * uroj) > sqrt(i.rzecz*i.rzecz + i.uroj * i.uroj))
  24.                 {
  25.                         return true;
  26.                 }
  27.                 else return false;
  28.  
  29.         }
  30.         friend istream &operator>>(istream &i,zespolona &o);
  31. };
  32.  
  33. istream & operator>>(istream &i,  zespolona &o)
  34. {
  35.         return i >> o.rzecz >> o.uroj;
  36. }
  37.  
  38. class tabzes
  39. {
  40. protected:
  41.         zespolona *tab;
  42.         int rozmiar, zajete;
  43. public:
  44.         tabzes() :tab(NULL),rozmiar(0),zajete(0) {};                            //konstruktor
  45.         tabzes(int r) :tab(new zespolona[r]),rozmiar(r),zajete(0) {};
  46.         zespolona & operator[](int i)
  47.         {
  48.                 if (i > zajete - 1||i<0)
  49.                 {
  50.                         throw out_of_range("Indeks poza zasiegiem");
  51.                 }
  52.                 else
  53.                 {
  54.                         return tab[i];
  55.                 }
  56.         }
  57.         tabzes & operator=(const tabzes &i)
  58.         {
  59.                 rozmiar = i.rozmiar;
  60.                 zajete = i.zajete;
  61.                 delete[] tab;
  62.                 if (i.rozmiar > 0)
  63.                 {
  64.                         tab = new zespolona[i.rozmiar];
  65.                         for (int j = 0; j < i.rozmiar; j++)
  66.                         {
  67.                                 tab[j] = i.tab[j];
  68.                         }
  69.                 }
  70.                 return *this;
  71.         }
  72.  
  73.         tabzes & operator+=(const zespolona &z) {
  74.                 if (rozmiar-zajete>0) {
  75.                         tab[zajete] = z;
  76.                         zajete++;
  77.                 }
  78.                 else {
  79.                         zespolona *temp = new zespolona[rozmiar + 1];
  80.                         for (int i = 0; i < rozmiar; i++) {
  81.                                 temp[i] = tab[i];
  82.                         }
  83.                         temp[zajete] = z;
  84.                         delete[] tab;
  85.                         tab = temp;
  86.                         zajete++;
  87.                         rozmiar++;
  88.                 }
  89.                 return *this;
  90.         }
  91. };
  92.  
  93. class kolzes:public tabzes
  94. {
  95. public:
  96.  
  97.         kolzes(int r) : tab(new zespolona[r]), rozmiar(r), zajete(0) {};
  98.  
  99.         friend istream & operator>>(istream &, kolzes &);
  100.         kolzes & operator +=(const zespolona &z) {
  101.                 if (rozmiar - zajete > 0)
  102.                 {
  103.                         int i = 0;
  104.                         while (i < zajete) {
  105.                                 if (tab[i] > z) {
  106.                                         int j = i;
  107.                                         for (j; j < zajete + 1; j++) {
  108.                                                 tab[j + 1] = tab[j];
  109.                                         }
  110.                                         break;
  111.                                 }
  112.                                 i++;
  113.                                 tab[i] = z;
  114.                         }
  115.                         zajete++;
  116.                 }
  117.                 else {
  118.                         zespolona *temp = new zespolona[rozmiar + 1];
  119.                         rozmiar++;
  120.                         for (int i = 0; i < rozmiar; i++) {
  121.                                 temp[i] = tab[i];
  122.                         }
  123.                         delete[] tab;
  124.                         tab = temp;
  125.                         int i = 0;
  126.                         while (i < zajete) {
  127.                                 if (tab[i] > z) {
  128.                                         int j = i;
  129.                                         for (j; j < zajete + 1; j++) {
  130.                                                 tab[j + 1] = tab[j];
  131.                                         }
  132.                                         break;
  133.                                 }
  134.                                 i++;
  135.                                 tab[i] = z;
  136.                         }
  137.                         zajete++;
  138.                 }
  139.                 return *this;
  140.         }
  141.         zespolona pop() {
  142.                 zespolona temp;
  143.                 if (tab == NULL||zajete==0) {
  144.                         throw out_of_range("Nie ma wiecej liczb do usuniecia");
  145.                 }
  146.                 else {
  147.                         temp = tab[0];
  148.                         for (int i = 0; i < zajete-1;i++) {
  149.                                 tab[i] = tab[i + 1];
  150.                         }
  151.                         zajete--;
  152.                 }
  153.                 return temp;
  154.         }
  155.         operator zespolona() {
  156.                 zespolona o;
  157.                 for (int i = 0; i < zajete; i++) {
  158.                         o += tab[i];
  159.                 }
  160.                 return o;
  161.         }
  162.  
  163. };
  164.  
  165. istream &operator>>(istream &i,kolzes &o) {
  166.         zespolona t;
  167.         while (i>>t) {
  168.                 o += t;
  169.         }
  170.         return i;
  171. }
  172.  
  173.  
  174.  
  175. int main()
  176. {
  177.     std::cout << "Hello World!\n";
  178. }
  179.  
  180. // Uruchomienie programu: Ctrl + F5 lub menu Debugowanie > Uruchom bez debugowania
  181. // Debugowanie programu: F5 lub menu Debugowanie > Rozpocznij debugowanie
  182.  
  183. // Porady dotycz─ůce rozpoczynania pracy:
  184. //   1. U┼╝yj okna Eksploratora rozwi─ůza┼ä, aby doda─ç pliki i zarz─ůdza─ç nimi
  185. //   2. U┼╝yj okna programu Team Explorer, aby nawi─ůza─ç po┼é─ůczenie z kontrol─ů ┼║r├│d┼éa
  186. //   3. U┼╝yj okna Dane wyj┼Ťciowe, aby sprawdzi─ç dane wyj┼Ťciowe kompilacji i inne komunikaty
  187. //   4. U┼╝yj okna Lista b┼é─Öd├│w, aby zobaczy─ç b┼é─Ödy
  188. //   5. Wybierz pozycj─Ö Projekt > Dodaj nowy element, aby utworzy─ç nowe pliki kodu, lub wybierz pozycj─Ö Projekt > Dodaj istniej─ůcy element, aby doda─ç istniej─ůce pliku kodu do projektu
  189. //   6. Aby w przysz┼éo┼Ťci ponownie otworzy─ç ten projekt, przejd┼║ do pozycji Plik > Otw├│rz > Projekt i wybierz plik sln
  190.  
  191.  
  192.