API tools faq
paste
Advertisement
czlowiekzgon

Untitled

czlowiekzgon
Nov 15th, 2018
126
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.72 KB | None | 0 0
raw download clone embed print report
  1. // programowanie_obiektowe.cpp : Ten plik zawiera funkcję „main”. W nim rozpoczyna się i kończy wykonywanie programu.
  2. #include "pch.h"
  3. #include <iostream>
  4. #include <string>
  5. #include "Assassin.h"
  6. #include "Gang.h"
  7.  
  8. using namespace std;
  9.  
  10.  
  11. void create(Gang *&ptr, int size = 1) {
  12.  
  13. ptr = new Gang[size];
  14. for (int i = 0; i < size; i++) {
  15. ptr[i].init();
  16. }
  17. }
  18.  
  19. void create(Assassin *&ptr, int size = 1) {
  20. ptr = new Assassin[size];
  21. for (int i = 0; i < size; i++) {
  22. ptr[i].init();
  23. }
  24. }
  25.  
  26. void create(Gang **&ptr, int size) {
  27. ptr = new Gang *[size];
  28. for (int i = 0; i < size; i++) {
  29. ptr[i] = new Gang;
  30. ptr[i]->init();
  31.  
  32. }
  33. }
  34.  
  35. void create(Assassin **&ptr, int size) {
  36. ptr = new Assassin *[size];
  37. for (int i = 0; i < size; i++) {
  38. ptr[i] = new Assassin;
  39. ptr[i]->init();
  40. }
  41. }
  42.  
  43.  
  44.  
  45.  
  46. void delete_memory(Gang *&ptr) {
  47. if (ptr == nullptr) {
  48. return;
  49. }
  50. else {
  51.  
  52. delete ptr;
  53. ptr = nullptr;
  54. }
  55. }
  56.  
  57. void delete_memory(Gang **&ptr, int n) {
  58. if (ptr == nullptr) {
  59. return;
  60. }
  61. else {
  62. for (int i = 0; i < n; i++) {
  63. delete[] ptr[n];
  64. }
  65. delete[] ptr;
  66. ptr = nullptr;
  67. }
  68. }
  69.  
  70. void delete_memory(Assassin *&ptr) {
  71. if (ptr == nullptr) {
  72. return;
  73. }
  74. else {
  75.  
  76. delete ptr;
  77. ptr = nullptr;
  78. }
  79. }
  80.  
  81. void delete_memory(Assassin **&ptr, int n) {
  82. if (ptr == nullptr) {
  83. return;
  84. }
  85. else {
  86. for (int i = 0; i < n; i++) {
  87. delete[] ptr[n];
  88. }
  89. delete[] ptr;
  90. ptr = nullptr;
  91. }
  92. }
  93.  
  94.  
  95. void add(Assassin *&ptr, int &size, int where = -1) {
  96.  
  97.  
  98. Assassin *sup_ptr = new Assassin[size + 1];
  99.  
  100. for (int i = 0; i < size + 1; i++) {
  101.  
  102. if (i == where) {
  103.  
  104. sup_ptr[i].init();
  105. }
  106. else if (i > where && where >= 0) {
  107. sup_ptr[i] = ptr[i - 1];
  108. }
  109. else if (i == size && where < 0) {
  110. sup_ptr[i].init();
  111. }
  112. else {
  113. sup_ptr[i] = ptr[i];
  114. }
  115.  
  116. }
  117.  
  118.  
  119. delete[] ptr;
  120. ptr = sup_ptr;
  121. ++size;
  122.  
  123. }
  124.  
  125. void add(Assassin **&ptr, int &size, int where = -1) {
  126.  
  127.  
  128. Assassin **sup_ptr = new Assassin *[size + 1];
  129.  
  130. for (int i = 0; i < size + 1; i++) {
  131.  
  132. if (i == where) {
  133. sup_ptr[i] = new Assassin;
  134. sup_ptr[i]->init();
  135. }
  136. else if (i > where && where >= 0) {
  137. sup_ptr[i] = ptr[i - 1];
  138. }
  139. else if (i == size && where < 0) {
  140. sup_ptr[i]->init();
  141. }
  142. else {
  143. sup_ptr[i] = ptr[i];
  144. }
  145.  
  146. }
  147.  
  148.  
  149. delete[] ptr;
  150. ptr = sup_ptr;
  151. ++size;
  152.  
  153. }
  154.  
  155. void add(Gang *&ptr, int &size, int where = -1) {
  156.  
  157.  
  158. Gang *sup_ptr = new Gang[size + 1];
  159.  
  160. for (int i = 0; i < size + 1; i++) {
  161.  
  162. if (i == where) {
  163.  
  164. sup_ptr[i].init();
  165. }
  166. else if (i > where && where >= 0) {
  167. sup_ptr[i] = ptr[i - 1];
  168. }
  169. else if (i == size && where < 0) {
  170. sup_ptr[i].init();
  171. }
  172. else {
  173. sup_ptr[i] = ptr[i];
  174. }
  175.  
  176. }
  177.  
  178.  
  179. delete[] ptr;
  180. ptr = sup_ptr;
  181. ++size;
  182.  
  183. }
  184.  
  185. void add(Gang **&ptr, int &size, int where = -1) {
  186.  
  187.  
  188. Gang **sup_ptr = new Gang *[size + 1];
  189. for (int i = 0; i < size + 1; i++) {
  190.  
  191. if (i == where) {
  192. sup_ptr[i] = new Gang;
  193. sup_ptr[i]->init();
  194. }
  195. else if (i > where && where >= 0) {
  196. sup_ptr[i] = ptr[i - 1];
  197. }
  198. else if (i == size && where < 0) {
  199. sup_ptr[i]->init();
  200. }
  201. else {
  202. sup_ptr[i] = ptr[i];
  203. }
  204.  
  205. }
  206.  
  207.  
  208. delete[] ptr;
  209. ptr = sup_ptr;
  210. ++size;
  211.  
  212.  
  213. }
  214. void remove(Assassin **&ptr, int &size, int where) {
  215. Assassin **sup_ptr = new Assassin *[size - 1];
  216.  
  217. for (int i = 0; i < size; i++) {
  218. if (i == where) {
  219. delete ptr[i];
  220. }
  221. else if (i < where) {
  222.  
  223. sup_ptr[i] = ptr[i];
  224.  
  225. }
  226. else {
  227.  
  228. sup_ptr[i - 1] = ptr[i];
  229.  
  230. }
  231. }
  232.  
  233.  
  234. delete[] ptr;
  235. ptr = sup_ptr;
  236. --size;
  237. }
  238.  
  239. void remove(Gang **&ptr, int &size, int where) {
  240. Gang **sup_ptr = new Gang *[size - 1];
  241.  
  242. for (int i = 0; i < size; i++) {
  243. if (i == where) {
  244. delete ptr[i];
  245. }
  246. else if (i < where) {
  247.  
  248. sup_ptr[i] = ptr[i];
  249.  
  250. }
  251. else {
  252.  
  253. sup_ptr[i - 1] = ptr[i];
  254.  
  255. }
  256. }
  257. delete[] ptr;
  258. ptr = nullptr;
  259. ptr = sup_ptr;
  260. --size;
  261. }
  262.  
  263. void remove(Assassin *&ptr, int &size, int where) {
  264. Assassin *sup_ptr = new Assassin[size - 1];
  265.  
  266. for (int i = 0; i < size; i++) {
  267.  
  268. if (i < where) {
  269.  
  270. sup_ptr[i] = ptr[i];
  271.  
  272. }else if(i == where) {
  273.  
  274. }
  275. else {
  276.  
  277. sup_ptr[i - 1] = ptr[i];
  278.  
  279. }
  280. }
  281.  
  282.  
  283. delete[] ptr;
  284. ptr = sup_ptr;
  285. --size;
  286. }
  287.  
  288. void remove(Gang *&ptr, int &size, int where) {
  289. Gang *sup_ptr = new Gang[size - 1];
  290.  
  291. for (int i = 0; i < size; i++) {
  292.  
  293. if (i < where) {
  294.  
  295. sup_ptr[i] = ptr[i];
  296.  
  297. }else if(i == where) {
  298.  
  299. }
  300. else {
  301.  
  302. sup_ptr[i - 1] = ptr[i];
  303.  
  304. }
  305. }
  306. delete[] ptr;
  307.  
  308. ptr = sup_ptr;
  309. --size;
  310. }
  311. void showMenu() {
  312. cout << "Wpisz : " << endl;
  313. cout << "[1] aby stworzyc obiket/obiekty klasy Gang" << endl;
  314. cout << "[2] aby stworzyc obiekt/obikety klasy Zabojca" << endl;
  315. cout << "[3] aby wyswietlic stworzone obiekty" << endl;
  316. cout << "[0] aby zaknocznyc" << endl;
  317. }
  318.  
  319. void showGangMenu() {
  320. cout << "[1] aby dodac pojedynycz obiekt klasy Gang" << endl;
  321. cout << "[2] aby dodac wiele obiektow klasy Gang" << endl;
  322. cout << "[3] aby dodac obiekt do istniejacej tablicy obiektow klasy gang" << endl;
  323. cout << "[4] aby dodac obiekt do istniejacej tablicy wskaznikow klasy gang" << endl;
  324. cout << "[5] aby usunac obiekt z istniejacej tablicy obiektow klasy gang" << endl;
  325. cout << "[6] aby usunac obiekt z istniejacej tablicy wskaznikow klasy gang" << endl;
  326. cout << "[0] aby zaknocznyc" << endl;
  327.  
  328. }
  329.  
  330. void showAssassinMenu() {
  331. cout << "[1] aby dodac wiele obiektow na pojedynczy wskaznik klasy Zabojca" << endl;
  332. cout << "[2] aby dodac wiele obiektow na podwojny wskaznik klasy Zabojca" << endl;
  333. cout << "[3] aby dodac obiekt do istniejacej tablicy obiektow klasy Zabojca" << endl;
  334. cout << "[4] aby dodac obiekt do istniejacej tablicy wskaznikow klasy Zabojca" << endl;
  335. cout << "[5] aby usunac obiekt z istniejacej tablicy wskaznikow klasy Zabojca" << endl;
  336. cout << "[6] aby usunac obiekt z istniejacej tablicy obiektow klasy Zabojca" << endl;
  337. cout << "[0] aby zaknocznyc" << endl;
  338. }
  339.  
  340. void gangMenu(Gang *&ptr_gang,Gang **&ptr_gangs,int &sizeArrayGang,int &sizeArrayGangs) {
  341. int gangChoice = 0;
  342.  
  343. int where = 0;
  344. do {
  345. showGangMenu();
  346. cin >> gangChoice;
  347. switch (gangChoice)
  348. {
  349. case 1:
  350. cout << "ile chcesz stworzyc obiektow" << endl;
  351. cin >> sizeArrayGang;
  352. create(ptr_gang, sizeArrayGang);
  353. break;
  354.  
  355. case 2:
  356. cout << "ile chcesz stworzyc obiektow" << endl;
  357. cin >> sizeArrayGangs;
  358. create(ptr_gangs, sizeArrayGangs);
  359. break;
  360.  
  361. case 3:
  362. cout << "w ktorym miejscu chcesz dodac element " << endl;
  363. cin >> where;
  364. add(ptr_gang, sizeArrayGang, where);
  365. break;
  366.  
  367. case 4:
  368. cout << "w ktorym miejscu chcesz dodac element " << endl;
  369. cin >> where;
  370. add(ptr_gangs, sizeArrayGangs, where);
  371. break;
  372.  
  373. case 5:
  374. cout << "w ktorym miejscu chcesz usunac element " << endl;
  375. cin >> where;
  376. remove(ptr_gang, sizeArrayGang, where);
  377. break;
  378.  
  379. case 6:
  380. cout << "w ktorym miejscu chcesz usunac element " << endl;
  381. cin >> where;
  382. remove(ptr_gangs, sizeArrayGangs, where);
  383. break;
  384.  
  385. case 0:
  386. break;
  387. default:
  388. cout << "Nie ma takiej opcji" << endl;
  389. break;
  390. }
  391. } while (gangChoice != 0);
  392.  
  393.  
  394.  
  395. }
  396.  
  397. void assassinMenu(Assassin *&ptr_assassin,Assassin **&ptr_assassins,int &sizeArrayAssassin,int &sizeArrayAssassins) {
  398. int assassinChoice = 0;
  399.  
  400. int where = 0;
  401. do {
  402. showAssassinMenu();
  403. cin >> assassinChoice;
  404. switch (assassinChoice)
  405. {
  406. case 1:
  407. cout << "ile chcesz stworzyc obiektow" << endl;
  408. cin >> sizeArrayAssassin;
  409. create(ptr_assassin, sizeArrayAssassin);
  410. break;
  411.  
  412. case 2:
  413. cout << "ile chcesz stworzyc obiektow" << endl;
  414. cin >> sizeArrayAssassins;
  415. create(ptr_assassins, sizeArrayAssassins);
  416. break;
  417.  
  418. case 3:
  419. cout << "w ktorym miejscu chcesz dodac element " << endl;
  420. cin >> where;
  421. add(ptr_assassin, sizeArrayAssassin, where);
  422. break;
  423.  
  424. case 4:
  425. cout << "w ktorym miejscu chcesz dodac element " << endl;
  426. cin >> where;
  427. add(ptr_assassins, sizeArrayAssassins, where);
  428. break;
  429.  
  430. case 5:
  431. cout << "w ktorym miejscu chcesz usunac element " << endl;
  432. cin >> where;
  433. remove(ptr_assassin, sizeArrayAssassin, where);
  434. break;
  435.  
  436. case 6:
  437. cout << "w ktorym miejscu chcesz usunac element " << endl;
  438. cin >> where;
  439. remove(ptr_assassins, sizeArrayAssassins, where);
  440. break;
  441.  
  442. case 0:
  443. break;
  444.  
  445. default:
  446. cout << "Nie ma takiej opcji" << endl;
  447. break;
  448. }
  449. } while (assassinChoice != 0);
  450.  
  451.  
  452.  
  453. }
  454. void showGangArray(Gang *&ptr_gang, int sizeArrayGang) {
  455. if (ptr_gang != nullptr && sizeArrayGang != 0) {
  456. for (int i = 0; i < sizeArrayGang; i++) {
  457. ptr_gang[i].show();
  458. }
  459. }
  460. else cout << "nie zalokowano pamieci dla tablic obiektow Gang" << endl;
  461. cout << endl;
  462.  
  463.  
  464. }
  465. void showGangsArray(Gang **&ptr_gangs,int sizeArrayGangs) {
  466. if (ptr_gangs != nullptr && sizeArrayGangs != 0) {
  467. for (int i = 0; i < sizeArrayGangs; i++) {
  468. ptr_gangs[i]->show();
  469. }
  470. }
  471. else cout << "nie zalokowano pamieci dla tablic wskaznikow obiektu Gang" << endl;
  472.  
  473. cout << endl;
  474.  
  475.  
  476. }
  477. void showAssassinArray(Assassin *&ptr_assassin,int sizeArrayAssassin) {
  478. if (ptr_assassin != nullptr && sizeArrayAssassin != 0) {
  479. for (int i = 0; i < sizeArrayAssassin; i++) {
  480. ptr_assassin[i].show();
  481. }
  482. }
  483. else cout << "nie zalokowano pamieci dla tablic obiektow Assassin" << endl;
  484. cout << endl;
  485. }
  486. void showAssassinsArray(Assassin **&ptr_assassins,int sizeArrayAssassins) {
  487. if (ptr_assassins != nullptr && sizeArrayAssassins != 0) {
  488. for (int i = 0; i < sizeArrayAssassins; i++) {
  489. ptr_assassins[i]->show();
  490. }
  491. }
  492. else cout << "nie zalokowano pamieci dla tablic wskaznikow obiektu Assassin" << endl;
  493. cout << endl;
  494. }
  495.  
  496.  
  497.  
  498.  
  499.  
  500.  
  501. void mainMenu(Gang *&ptr_gang, Gang **&ptr_gangs, Assassin *&ptr_assassin, Assassin **&ptr_assassins) {
  502. int choiceMenu = 0;
  503. int sizeArrayGang = 0;
  504. int sizeArrayGangs = 0;
  505. int sizeArrayAssassin = 0;
  506. int sizeArrayAssassins = 0;
  507. do {
  508. showMenu();
  509. cin >> choiceMenu;
  510.  
  511. switch (choiceMenu)
  512. {
  513. case 1:
  514. gangMenu(ptr_gang, ptr_gangs,sizeArrayGang,sizeArrayGangs);
  515. break;
  516.  
  517. case 2:
  518. assassinMenu(ptr_assassin, ptr_assassins,sizeArrayAssassin,sizeArrayAssassins);
  519. break;
  520.  
  521. case 3:
  522. showGangArray(ptr_gang, sizeArrayGang);
  523. showGangsArray(ptr_gangs, sizeArrayGangs);
  524. showAssassinArray(ptr_assassin, sizeArrayAssassin);
  525. showAssassinsArray(ptr_assassins, sizeArrayAssassins);
  526. break;
  527.  
  528. case 0:
  529. break;
  530.  
  531. default:
  532. cout << "Nie ma takiej opcji" << endl;
  533. break;
  534.  
  535. }
  536.  
  537. } while (choiceMenu != 0);
  538.  
  539.  
  540. }
  541.  
  542.  
  543. int main(int argc, char** argv)
  544. {
  545. Gang *ptr_gang = nullptr;
  546. Gang **ptr_gangs = nullptr;
  547. Assassin *ptr_assassin = nullptr;
  548. Assassin **ptr_assassins = nullptr;
  549. int size = 2;
  550. mainMenu(ptr_gang, ptr_gangs, ptr_assassin, ptr_assassins);
  551.  
  552.  
  553.  
  554. return 0;
  555. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!