Guest User

Untitled

a guest
Jun 24th, 2018
63
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 12.17 KB | None | 0 0
  1. /*
  2. * Schemat dziedziczenia klas
  3. * ZYWNOSC
  4. * / \
  5. * OWOC WARZYWO
  6. * / \ / \
  7. * JABLKO POMARANCZA MARCHEW BURAK
  8. *
  9. *ZYWNOSC
  10. * - wartosc_odzywcza
  11. * - nazwa
  12. *
  13. *
  14. *WARZYWO
  15. * - wartosc_odzywcza
  16. * - nazwa
  17. * - swieze
  18. *
  19. *MARCHEW
  20. * - wartosc_odzywcza
  21. * - nazwa
  22. * - swieze
  23. * - dlugosc_korzenia
  24. *BURAK
  25. * - wartosc_odzywcza
  26. * - nazwa
  27. * - swieze
  28. * - cukrowy
  29. *
  30. *
  31. *OWOC
  32. * - wartosc_odzywcza
  33. * - nazwa
  34. * - cytrusowy
  35. * - witamina
  36. *
  37. *JABLKO
  38. * - wartosc_odzywcza
  39. * - nazwa
  40. * - cytrusowy
  41. * - witamina
  42. * - odmiana
  43. *POMARANCZA
  44. * - wartosc_odzywcza
  45. * - nazwa
  46. * - cytrusowy
  47. * - witamina
  48. * - bezpestkowa
  49. */
  50.  
  51. #include <vector>
  52. #include <cstdlib>
  53. #include <iostream>
  54. #include <fstream>
  55. #include <sstream>
  56. #include <cstring>
  57.  
  58.  
  59. using namespace std;
  60.  
  61. /*** ZYWNOSC ***/
  62.  
  63. /*
  64. * Klasa macierzysta dla pozostalych klas w programie
  65. * Przechowuje informacje o nazwie i wartosci odzywczej danego rodzaju zywnosci
  66. */
  67. class Zywnosc {
  68. protected:
  69. float wartosc_odzywcza;
  70. char * nazwa;
  71.  
  72. void ustaw_nazwe(const char * _nazwa) {
  73. // przepisanie nazwy do zmiennej wlasnosci
  74. nazwa = new char[strlen(_nazwa)];
  75. strcpy(nazwa, _nazwa);
  76. }
  77. public:
  78.  
  79. Zywnosc() {
  80. }
  81.  
  82. Zywnosc(const char * _nazwa, float w_odzywcza) : wartosc_odzywcza(w_odzywcza) {
  83. ustaw_nazwe(_nazwa);
  84. }
  85.  
  86. Zywnosc(const Zywnosc & cpy) :
  87. wartosc_odzywcza(cpy.pokaz_w_odzywcza()) {
  88. ustaw_nazwe(cpy.pokaz_nazwe());
  89. }
  90.  
  91. string podstawowe_info(){
  92. stringstream str;
  93. str << pokaz_nazwe()
  94. << ", wartosc odzywcza: " << pokaz_w_odzywcza() << "kcal";
  95. return str.str();
  96. }
  97.  
  98. //metoda wirtualna tworzaca ciag do zapisu obiektu do pliku
  99.  
  100. virtual string konwertuj_do_zapisu() {
  101. return "";
  102. }
  103.  
  104. //metoda wirtualna tworzaca ciag informacyjny na temat obiektu
  105.  
  106. virtual string konwertuj_do_prezentacji(){
  107. return podstawowe_info();
  108. }
  109. // akcesory wlasnosci
  110.  
  111. float pokaz_w_odzywcza() const {
  112. return wartosc_odzywcza;
  113. }
  114.  
  115. char * pokaz_nazwe() const {
  116. return nazwa;
  117. }
  118. };
  119.  
  120. // Przeciazony operator wyprowadzenia na strumien wyjsciowy
  121.  
  122. ostream & operator <<(ostream & strumien, Zywnosc z) {
  123. strumien << z.konwertuj_do_prezentacji();
  124. return strumien;
  125. }
  126.  
  127. /*** WARZYWO ***/
  128.  
  129. /*
  130. * Klasa modelujaca warzywa. Rozszerza Zywnosc o informacje czy
  131. * warzywo jest swieze
  132. */
  133. class Warzywo : public Zywnosc {
  134. protected:
  135. bool swieze;
  136. public:
  137.  
  138. Warzywo() {
  139. }
  140.  
  141. Warzywo(const char * _nazwa, float w_odzywcza, bool _swieze) :
  142. Zywnosc(_nazwa, w_odzywcza), swieze(_swieze) {
  143. }
  144.  
  145. Warzywo(const Warzywo & cpy) :
  146. Zywnosc(cpy.pokaz_nazwe(), cpy.pokaz_w_odzywcza()), swieze(cpy.czy_swieze()) {
  147. }
  148.  
  149. virtual string konwertuj_do_zapisu() {
  150. return "";
  151. }
  152.  
  153. virtual string konwertuj_do_prezentacji(){
  154. stringstream str;
  155. str << podstawowe_info() << (czy_swieze() ? ", swieze" : ", mrozone");
  156. return str.str();
  157. }
  158.  
  159. bool czy_swieze() const {
  160. return swieze;
  161. }
  162. };
  163.  
  164. ostream & operator <<(ostream & strumien, Warzywo w) {
  165. strumien << w.konwertuj_do_prezentacji();
  166. return strumien;
  167. }
  168.  
  169. /*** MARCHEW ***/
  170.  
  171. /*
  172. * Klasa marchwi, dziedziczy po Warzywie. Rozszerza je o dlugosc korzenia
  173. * i stosowny akcesor
  174. */
  175. class Marchew : public Warzywo {
  176. protected:
  177. float dlugosc_korzenia;
  178. public:
  179.  
  180. Marchew(float dl_korzenia, float w_odzywcza, bool _swieze) :
  181. Warzywo("Marchew", w_odzywcza, _swieze), dlugosc_korzenia(dl_korzenia) {
  182. }
  183.  
  184. Marchew(Marchew & cpy) :
  185. Warzywo("Marchew", cpy.pokaz_w_odzywcza(), cpy.czy_swieze()), dlugosc_korzenia(cpy.daj_dl_korzenia()) {
  186.  
  187. }
  188.  
  189. explicit Marchew(istream & strumien) {
  190. ustaw_nazwe("Marchew");
  191. strumien >> wartosc_odzywcza >> swieze >> dlugosc_korzenia;
  192. }
  193.  
  194. string konwertuj_do_zapisu() {
  195. stringstream bufor;
  196. bufor << nazwa << " "
  197. << wartosc_odzywcza << " "
  198. << swieze << " "
  199. << dlugosc_korzenia;
  200. return bufor.str();
  201. }
  202.  
  203. string konwertuj_do_prezentacji(){
  204. stringstream str;
  205. str << Warzywo::konwertuj_do_prezentacji() << endl << "Korzen dlugosci: " << daj_dl_korzenia();
  206. return str.str();
  207. }
  208.  
  209. float daj_dl_korzenia() const {
  210. return dlugosc_korzenia;
  211. }
  212. };
  213.  
  214.  
  215. /*** BURAK ***/
  216.  
  217. /*
  218. * Dziedziczy po warzywie, rozszerza je o informacje czy jest cukrowy.
  219. * Zapewnia odpowiedni akcesor.
  220. */
  221. class Burak : public Warzywo {
  222. protected:
  223. bool cukrowy;
  224. public:
  225.  
  226. Burak(bool _cukrowy, float w_odzywcza, bool _swieze) :
  227. Warzywo("Burak", w_odzywcza, _swieze), cukrowy(_cukrowy) {
  228. }
  229.  
  230. Burak(Burak & cpy) :
  231. Warzywo("Burak", cpy.pokaz_w_odzywcza(), cpy.czy_swieze()), cukrowy(cpy.czy_cukrowy()) {
  232. }
  233.  
  234. explicit Burak(istream & strumien) {
  235. ustaw_nazwe("Burak");
  236. strumien >> wartosc_odzywcza >> swieze >> cukrowy;
  237. }
  238.  
  239. string konwertuj_do_zapisu() {
  240. stringstream bufor;
  241. bufor << nazwa << " "
  242. << wartosc_odzywcza << " "
  243. << swieze << " "
  244. << cukrowy;
  245. return bufor.str();
  246. }
  247.  
  248. string konwertuj_do_prezentacji(){
  249. stringstream str;
  250. str << Warzywo::konwertuj_do_prezentacji() << endl << (czy_cukrowy() ? "Nie jest cukrowy" : "Jest cukrowy");
  251. return str.str();
  252. }
  253.  
  254. bool czy_cukrowy() const {
  255. return cukrowy;
  256. }
  257. };
  258.  
  259.  
  260. /*** OWOC ***/
  261.  
  262. /*
  263. * Rozszerza Zywnosc o informacje czy jest cytrusowy i jaka ma witamine.
  264. * Zapewnia odpowiednie akcesory
  265. */
  266. class Owoc : public Zywnosc {
  267. protected:
  268. bool cytrusowy;
  269. char witamina;
  270. public:
  271.  
  272. Owoc() {
  273. }
  274.  
  275. Owoc(const char * _nazwa, float w_odzywcza, bool _cytrus, char _witamina) :
  276. Zywnosc(_nazwa, w_odzywcza), cytrusowy(_cytrus), witamina(_witamina) {
  277. }
  278.  
  279. Owoc(const Owoc & cpy) :
  280. Zywnosc(cpy.pokaz_nazwe(), cpy.pokaz_w_odzywcza()), cytrusowy(cpy.czy_jest_cytrusem()),
  281. witamina(cpy.pokaz_witamine()) {
  282. }
  283.  
  284. virtual string konwertuj_do_zapisu() {
  285. return "";
  286. }
  287.  
  288. virtual string konwertuj_do_prezentacji(){
  289. stringstream str;
  290. str << podstawowe_info() << ", owoc "
  291. << (czy_jest_cytrusem() ? "cytrusowy" : "niecytrusowy")
  292. << endl << "Zawiera witamine " << pokaz_witamine();
  293. return str.str();
  294. }
  295.  
  296. bool czy_jest_cytrusem() const {
  297. return cytrusowy;
  298. }
  299.  
  300. char pokaz_witamine() const {
  301. return witamina;
  302. }
  303. };
  304.  
  305.  
  306. /*** JABLKO ***/
  307.  
  308. /*
  309. * Modeluje klase jablka rozszerzajac Owoc o wlasnosc odmiana.
  310. */
  311. class Jablko : public Owoc {
  312. private:
  313. char * odmiana;
  314.  
  315. void ustaw_odmiane(const char * _odmiana) {
  316. odmiana = new char[strlen(_odmiana)];
  317. strcpy(odmiana, _odmiana);
  318. }
  319. public:
  320.  
  321. Jablko(const char * _odmiana, float w_odzywcza) :
  322. Owoc("Jablko", w_odzywcza, false, 'D') {
  323. ustaw_odmiane(_odmiana);
  324. }
  325.  
  326. Jablko(Jablko & cpy) :
  327. Owoc("Jablko", cpy.pokaz_w_odzywcza(), false, 'D') {
  328. ustaw_odmiane(cpy.pokaz_odmiane());
  329. }
  330.  
  331. explicit Jablko(istream & strumien) {
  332. ustaw_nazwe("Jablko");
  333. char tmp_odmiana[30];
  334. strumien >> wartosc_odzywcza
  335. >> witamina
  336. >> cytrusowy;
  337. strumien.get();
  338. strumien >> tmp_odmiana;
  339. odmiana = new char(strlen(tmp_odmiana));
  340. strcpy(odmiana, tmp_odmiana);
  341. }
  342.  
  343. string konwertuj_do_zapisu() {
  344. stringstream bufor;
  345. bufor << nazwa << " "
  346. << wartosc_odzywcza << " "
  347. << witamina << " "
  348. << cytrusowy << " "
  349. << odmiana;
  350. return bufor.str();
  351. }
  352.  
  353. string konwertuj_do_prezentacji(){
  354. stringstream str;
  355. str << Owoc::konwertuj_do_prezentacji() << endl << "Odmiana: " << pokaz_odmiane();
  356. return str.str();
  357. }
  358.  
  359. char * pokaz_odmiane() const {
  360. return odmiana;
  361. }
  362. };
  363.  
  364.  
  365. /*** POMARANCZA ***/
  366.  
  367. /*
  368. * Dziedziczy po Owoc, rozszerza go o informacje czy to odmiana bezpestkowa
  369. */
  370. class Pomarancza : public Owoc {
  371. private:
  372. bool bezpestkowa;
  373. public:
  374.  
  375. Pomarancza(bool _bezpestkowa, float w_odzywcza) :
  376. Owoc("Pomarancza", w_odzywcza, true, 'C'),
  377. bezpestkowa(_bezpestkowa) {
  378. }
  379.  
  380. Pomarancza(const Pomarancza & cpy) :
  381. Owoc("Pomarancza", cpy.pokaz_w_odzywcza(), true, 'C'),
  382. bezpestkowa(cpy.czy_bezpestkowa()) {
  383. }
  384.  
  385. explicit Pomarancza(istream & strumien) {
  386. ustaw_nazwe("Pomarancza");
  387. strumien >> wartosc_odzywcza
  388. >> witamina
  389. >> cytrusowy
  390. >> bezpestkowa;
  391. }
  392.  
  393. string konwertuj_do_zapisu() {
  394. stringstream bufor;
  395. bufor << nazwa << " "
  396. << wartosc_odzywcza << " "
  397. << witamina << " "
  398. << cytrusowy << " "
  399. << bezpestkowa;
  400. return bufor.str();
  401. }
  402.  
  403. string konwertuj_do_prezentacji(){
  404. stringstream str;
  405. str << Owoc::konwertuj_do_prezentacji()
  406. << endl << "Odmiana " << (czy_bezpestkowa() ? "bezpestkowa" : "z pestkami");
  407. return str.str();
  408. }
  409.  
  410. bool czy_bezpestkowa() const {
  411. return bezpestkowa;
  412. }
  413. };
  414.  
  415. /*** KOSZYCZEK ***/
  416. /*
  417. * Klasa kontenera zywnosci
  418. * Posiada metody sluzace dodawaniu nowych elementow do listy oraz czyszczenia listy
  419. * Udostepnia mozliwosc zapisu do pliku i odczytu z pliku
  420. */
  421. class Koszyczek {
  422. vector<Zywnosc*> zawartosc;
  423. public:
  424.  
  425. Koszyczek & dodaj(Zywnosc * zyw) {
  426. zawartosc.push_back(zyw);
  427. return *this;
  428. }
  429.  
  430. void zapisz(const char *nazwa_pliku) {
  431. ofstream plik(nazwa_pliku);
  432. // Jesli nie udalo sie otworzyc pliku do zapisu
  433. if (!plik.is_open()) {
  434. cerr << "Blad otwarcia pliku!" << endl;
  435. return;
  436. }
  437. // Glowna petla zapisu
  438. for (int i = 0; i < zawartosc.size(); ++i) {
  439. plik << zawartosc[i]->konwertuj_do_zapisu() << endl;
  440. }
  441. plik.close();
  442. }
  443.  
  444. void odczyt(const char * nazwa_pliku) {
  445. ifstream plik(nazwa_pliku);
  446. // Jesli nie udalo sie czytac z pliku
  447. if (!plik.is_open()) {
  448. cerr << "Blad otwarcia pliku!" << endl;
  449. return;
  450. }
  451. char tmp_nazwa[20];
  452. // Glowna petla odczytu kolejnych linii
  453. while (plik.get() != EOF) {
  454. plik.unget();
  455. plik >> tmp_nazwa;
  456. if (!strcmp(tmp_nazwa, "Burak")) {
  457. dodaj(new Burak(plik));
  458. } else if (!strcmp(tmp_nazwa, "Marchew")) {
  459. dodaj(new Marchew(plik));
  460. } else if (!strcmp(tmp_nazwa, "Jablko")) {
  461. dodaj(new Jablko(plik));
  462. } else if (!strcmp(tmp_nazwa, "Pomarancza")) {
  463. dodaj(new Pomarancza(plik));
  464. } else break;
  465. plik.get();
  466. }
  467. plik.close();
  468. }
  469.  
  470. // Czyszczenie zawartosci koszyka
  471. void oproznij() {
  472. zawartosc.clear();
  473. }
  474.  
  475. // Wyswietlenie zawartosci koszyka
  476. void prezentuj() {
  477. cout << "ZAWARTOSC KOSZYCZKA" << endl;
  478. if (zawartosc.empty())
  479. cout << "<koszyk jest pusty>" << endl;
  480. else
  481. for (int i = 0; i < zawartosc.size(); ++i)
  482. cout << (i + 1) << ". ELEMENT:" << endl << zawartosc[i]->konwertuj_do_prezentacji() << endl;
  483. }
  484. };
  485.  
  486.  
  487. int main(int argc, char** argv) {
  488. Koszyczek k;
  489. // dodanie do koszyczka warzyw i owocow
  490. k.dodaj(new Jablko("reneta", 10))
  491. .dodaj(new Marchew(8, 21, true))
  492. .dodaj(new Burak(false, 7, true))
  493. .dodaj(new Pomarancza(false, 12));
  494. // zapis do pliku
  495. k.zapisz("omg.dat");
  496. // czyszczenie lokalnego buforu
  497. k.oproznij();
  498. // odczyt danych z pliku
  499. k.odczyt("omg.dat");
  500. // prezentacja wczytanych danych
  501. k.prezentuj();
  502. return (EXIT_SUCCESS);
  503. }
Add Comment
Please, Sign In to add comment