Advertisement
Matqux

gepjaramunyilvantartas

Dec 8th, 2019
363
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 20.71 KB | None | 0 0
  1. //*****************************************//
  2. //---Gépjármű nyilvántartó szoftver    ---//
  3. //---Megbízó: Wheelmos és Társa Kft.    ---//
  4. //---Készítette: Tószegi Máté          ---//
  5. //---Dátum: 2019.12.08                 ---//
  6. //*****************************************//
  7.  
  8. //megjegyzes: a megvalositas soran strazsa nelkuli listat alkalmazunk
  9.  
  10. #include <stdio.h>
  11. //#include <stdlib.h>
  12. #include <string.h>
  13. #include <math.h>
  14. #include <limits.h>
  15.  
  16. //a jarmu struktura definialasa
  17. typedef struct jarmu
  18. {
  19.     //adatok
  20.     char rendszam[7 + 1];
  21.     char gyarto[7 + 1];
  22.     char tipus[7 + 1];
  23.     int evjarat;
  24.     char szin[7 + 1];
  25.     int ferohely;
  26.     int hengerur;
  27.     int teljesitmeny;
  28.  
  29.     //jellemzok
  30.     char szarmazas[7 + 1];
  31.     int kilometer;
  32.     int hibakod;
  33.     int allapot;
  34.     int elado;
  35.     int ar;
  36. }jarmu;
  37.  
  38. //egy listaelem definialasa
  39. typedef struct listelem
  40. {
  41.     jarmu data;
  42.     struct listelem* next;
  43.  
  44. }listelem;
  45.  
  46. //fuggveny a hatra beszurashoz, ket bemeno parametere
  47. listelem* beszurHatra(listelem* list, jarmu data)
  48. {
  49.     if (list == NULL) //ha ures a lista, akkor felepitjuk az első elemet
  50.     {
  51.         listelem* uj = (listelem*)malloc(sizeof(listelem));
  52.         uj->next = NULL;
  53.         uj->data = data;
  54.         return uj;
  55.     }
  56.     else //egyebkent beszurunk a vegere
  57.     {
  58.         listelem* p = list;
  59.         while (p->next != NULL)
  60.         {
  61.             p = p->next;
  62.         }
  63.  
  64.         listelem* uj = (listelem*)malloc(sizeof(listelem));
  65.         uj->next = NULL;
  66.         uj->data = data;
  67.         p->next = uj;
  68.         return list;
  69.  
  70.     }
  71. }
  72.  
  73.  
  74. //fuggveny, mely megadja, hogy egy adott elem megfelel-e a szuresi parametereknek
  75. //visszaeteresi erteke 1, ha megfelel, 0, ha nem felel meg az adott elem
  76. //elso ranezesre tobb fuggvenyre lehene bontani azonban az adattipusok elterese es a kezelesuk egyszerubbe teszi a jelnlegi fuggveny hasznalatat
  77. int szures(jarmu *p, jarmu *szuromin, jarmu *szuromax)
  78. {
  79.     int jo = 1;
  80.  
  81.     if (strcmp(szuromin->rendszam, "-") != 0)
  82.     {
  83.         if (strcmp(szuromin->rendszam, p->rendszam) != 0)
  84.         {
  85.             jo = 0;
  86.         }
  87.     }
  88.  
  89.     if (strcmp(szuromin->gyarto, "-") != 0)
  90.     {
  91.         if (strcmp(szuromin->gyarto, p->gyarto) != 0)
  92.         {
  93.             jo = 0;
  94.         }
  95.     }
  96.  
  97.     if (strcmp(szuromin->tipus, "-") != 0)
  98.     {
  99.         if (strcmp(szuromin->tipus, p->tipus) != 0)
  100.         {
  101.             jo = 0;
  102.         }
  103.     }
  104.  
  105.     if (szuromin->evjarat != -1)
  106.     {
  107.         if (szuromin->evjarat > p->evjarat || szuromax->evjarat < p->evjarat)
  108.         {
  109.             jo = 0;
  110.         }
  111.     }
  112.  
  113.     if (strcmp(szuromin->szin, "-") != 0)
  114.     {
  115.         if (strcmp(szuromin->szin, p->szin) != 0)
  116.         {
  117.             jo = 0;
  118.         }
  119.     }
  120.  
  121.     if (szuromin->ferohely != -1)
  122.     {
  123.         if (szuromin->ferohely != p->ferohely)
  124.         {
  125.             jo = 0;
  126.         }
  127.     }
  128.  
  129.     if (szuromin->hengerur != -1)
  130.     {
  131.         if (szuromin->hengerur > p->hengerur || szuromax->hengerur < p->hengerur)
  132.         {
  133.             jo = 0;
  134.         }
  135.     }
  136.  
  137.     if (szuromin->teljesitmeny != -1)
  138.     {
  139.         if (szuromin->teljesitmeny > p->teljesitmeny || szuromax->teljesitmeny < p->teljesitmeny)
  140.         {
  141.             jo = 0;
  142.         }
  143.     }
  144.  
  145.     if (strcmp(szuromin->szarmazas, "-") != 0)
  146.     {
  147.         if (strcmp(szuromin->szarmazas, p->szarmazas) != 0)
  148.         {
  149.             jo = 0;
  150.         }
  151.     }
  152.  
  153.     if (szuromin->kilometer != -1)
  154.     {
  155.         if (szuromin->kilometer > p->kilometer || szuromax->kilometer < p->kilometer)
  156.         {
  157.             jo = 0;
  158.         }
  159.     }
  160.  
  161.     if (szuromin->hibakod != -1)
  162.     {
  163.         if (szuromin->hibakod != p->hibakod)
  164.         {
  165.             jo = 0;
  166.         }
  167.     }
  168.  
  169.     if (szuromin->allapot != -1)
  170.     {
  171.         if (szuromin->allapot != p->allapot)
  172.         {
  173.             jo = 0;
  174.         }
  175.     }
  176.  
  177.     if (szuromin->elado != -1)
  178.     {
  179.         if (szuromin->elado != p->elado)
  180.         {
  181.             jo = 0;
  182.         }
  183.     }
  184.  
  185.     if (szuromin->ar != -1)
  186.     {
  187.         if (szuromin->ar > p->ar || szuromax->ar < p->ar)
  188.         {
  189.             jo = 0;
  190.         }
  191.     }
  192.     return jo;
  193. }
  194.  
  195. //fuggveny, mely a lista minden elemet kiirja
  196. void kiirMindet(listelem* list)
  197. {
  198.     listelem* p = list;
  199.     while (p != NULL)
  200.     {
  201.         printf("%s\t%s\t%s\t%d\t%s\t%d\t%d\t%d\t%s\t%d\t%d\t%d\t%d\t", p->data.rendszam, p->data.gyarto, p->data.tipus, p->data.evjarat, p->data.szin, p->data.ferohely, p->data.hengerur, p->data.teljesitmeny, p->data.szarmazas, p->data.kilometer, p->data.hibakod, p->data.allapot, p->data.elado);
  202.  
  203.         if (p->data.elado == 1)
  204.         {
  205.             printf("%d\n", p->data.ar);
  206.         }
  207.         else
  208.         {
  209.             printf("\n");
  210.         }
  211.  
  212.         p = p->next;
  213.     }
  214.  
  215.  
  216. }
  217.  
  218. //kiiro fuggveny, egy adott sor adatat irja ki adott listabol
  219. void kiirSort(listelem *p)
  220. {
  221.     printf("%s\t%s\t%s\t%d\t%s\t%d\t%d\t%d\t%s\t%d\t%d\t%d\t%d\t", p->data.rendszam, p->data.gyarto, p->data.tipus, p->data.evjarat, p->data.szin, p->data.ferohely, p->data.hengerur, p->data.teljesitmeny, p->data.szarmazas, p->data.kilometer, p->data.hibakod, p->data.allapot, p->data.elado);
  222.  
  223.     if (p->data.elado == 1)
  224.     {
  225.         printf("%d\n", p->data.ar);
  226.     }
  227.     else
  228.     {
  229.         printf("\n");
  230.     }
  231. }
  232.  
  233. //fuggveny, mely megnezi, hogy elozoleg sikeres volt-e a beolvasas a konzolrol
  234. //ha nem, akkor a 2db gethar a felesleges karaktereket beolvassa, ezzel uritve a bemeneti puffert
  235. void pufferCheck(int in)
  236. {
  237.     if (in == 0)
  238.     {
  239.         getchar(); //az elozo x-bevitelt lekezeljuk, beolvassuk ahz x-ez majd az utana levo szokozt
  240.         getchar();
  241.     }
  242. }
  243.  
  244. //fuggveny, mely lekezeli az olyan eseteket, melyeknek also/felso hatarertek is beviheto
  245. //scanmin es scanmax: sikerult-e max illetve min erteket olvasni
  246. //minval es maxval: a felhasznalo altal bevitt max es min erteke
  247. //szuromin, szuromax:  a modositando elemek cimei
  248. void minmaxWrite(int *scanmin, int *scanmax, int *minval, int *maxval, int *szuromin, int *szuromax)
  249. {
  250.     if (*scanmax == 0)
  251.     {
  252.         *szuromax = INT_MAX;
  253.     }
  254.     else
  255.     {
  256.         *szuromax = *maxval;
  257.     }
  258.  
  259.     if (*scanmin == 0)
  260.     {
  261.         *szuromin = INT_MIN;
  262.     }
  263.     else
  264.     {
  265.         *szuromin = *minval;
  266.     }
  267. }
  268.  
  269.  
  270. //fuggveny, mely a bevitt ertekeket beirja a min es max strukturaba, de csak azokban az esetekben, ahol erre a hatarertekes szuresre lehetoseg van
  271. //bemeno parameterei  a minmaxWrite() fuggvenyhez hasonloak
  272. void writeFilters(int *scanmin, int *scanmax, int *minval, int *maxval, char item, jarmu *szuromin, jarmu *szuromax)
  273. {
  274.     switch(item)
  275.     {
  276.         case 'r':
  277.             break;
  278.         case 'g':
  279.             break;
  280.         case 't':
  281.             break;
  282.         case 'e':
  283.             minmaxWrite(scanmin, scanmax, minval, maxval, &szuromin->evjarat, &szuromax->evjarat);
  284.             break;
  285.         case 's':
  286.             break;
  287.         case 'u':
  288.             break;
  289.         case 'h':
  290.             minmaxWrite(scanmin, scanmax, minval, maxval, &szuromin->hengerur, &szuromax->hengerur);
  291.             /*if (*scanmax == 0)
  292.             {
  293.                 szuromax->hengerur = INT_MAX;
  294.             }
  295.             else
  296.             {
  297.                 szuromax->hengerur = *maxval;
  298.             }
  299.  
  300.             if (*scanmin == 0)
  301.             {
  302.                 szuromin->hengerur = INT_MIN;
  303.             }
  304.             else
  305.             {
  306.                 szuromin->hengerur = *minval;
  307.             }*/
  308.             break;
  309.         case 'l':
  310.             minmaxWrite(scanmin, scanmax, minval, maxval, &szuromin->teljesitmeny, &szuromax->teljesitmeny);
  311.             break;
  312.         case 'o':
  313.             break;
  314.         case 'k':
  315.             minmaxWrite(scanmin, scanmax, minval, maxval, &szuromin->kilometer, &szuromax->kilometer);
  316.             break;
  317.         case 'c':
  318.             break;
  319.         case 'a':
  320.             break;
  321.         case 'f':
  322.             break;
  323.         case 'p':
  324.             minmaxWrite(scanmin, scanmax, minval, maxval, &szuromin->ar, &szuromax->ar);
  325.             break;
  326.     }
  327. }
  328.  
  329. //felszabadito fuggveny, az egesz listat torli a memoriabol
  330. void felszabadit(listelem *list)
  331. {
  332.     while (list != NULL)
  333.     {
  334.         listelem *next = list->next; //eltaroljuk kulon valtozoban a kovetkezo elem cimet, hiszen az elso elem torlesevel nem tudnank elerni a lista tobbi elemet
  335.         free(list);
  336.         //printf("%p felszabadtva\n", list);
  337.         list = next;
  338.     }
  339. }
  340.  
  341.  
  342. //fuggveny uj szuro felvetelehez
  343. //bemenoparameteri a max es min strukturak cimei, ezekbe ir
  344. void create_new_filter(jarmu *szuromin, jarmu *szuromax)
  345. {
  346.     int voltjo = 0;
  347.     do //addig maradunk a menuben, amig nem x karakter erkezik, ezt a switch-case figyeli
  348.     {
  349.         system("cls");
  350.  
  351.         int scanmin = 1;
  352.         int scanmax = 1;
  353.         int maxval = INT_MIN;
  354.         int minval = INT_MAX;
  355.  
  356.         printf//a szurok menu kiirasa
  357.         (
  358.             "Szuro beallitasa:\n"
  359.             "(Valassza ki mire szeretne szurni)\n"
  360.             "r: rendszam\n"
  361.             "g: gyarto\n"
  362.             "t: tipus\n"
  363.             "e: evjarat\n"
  364.             "s: szin\n"
  365.             "u: ulohelyek szama\n"
  366.             "h: hengerurtaralom\n"
  367.             "l: teljesitmeny(le)\n"
  368.             "o: szarmazas (origin)\n"
  369.             "k: kilometeroraallas\n"
  370.             "c: hibakod (code)\n"
  371.             "a: allapot\n"
  372.             "f: elado(for sale)\n"
  373.             "p: ar(price)\n"
  374.             "x: visszalepes a fomenube\n"
  375.         );
  376.         char filter;
  377.         scanf("%c%*c", &filter); //szuro karakter bekerese
  378.         switch (filter)
  379.         {
  380.         case 'r': //ha r, akkor rendszamra szurunk
  381.             system("cls");
  382.  
  383.             printf("Adjon meg egy rendszamot!\n");
  384.             char rendszam[7 + 1];
  385.             scanf("%s%*c", rendszam);
  386.  
  387.             strcpy(szuromin->rendszam, rendszam); //bekerjuk a rendszamot es bemasoljuk azt a szuro adott helyere, ezt minden mas valtozoval ugyan igy elvegezve a szuro valtozo egy olyan adat lesz, melyben minden adat \t és -1, kivéve a beállított értékek
  388.             strcpy(szuromax->rendszam, rendszam);
  389.  
  390.             //voltjo = 0; //0-ra állítjuk, hogy benne maradjunk a ciklusban (nem lenne szukseges, de igy biztonsagosabb),
  391.             break;
  392.         case 'g':
  393.         {
  394.             system("cls");
  395.             printf("Adjon meg egy gyartot!\n");
  396.  
  397.             char gyarto[7 + 1];
  398.             scanf("%s%*c", gyarto);
  399.  
  400.             strcpy(szuromin->gyarto, gyarto);
  401.             strcpy(szuromax->gyarto, gyarto);
  402.  
  403.             //voltjo = 0;
  404.             break;
  405.         }
  406.         case 't':
  407.         {
  408.             system("cls");
  409.             printf("Adjon meg egy tipust!\n");
  410.             char tipus[7 + 1];
  411.             scanf("%s%*c", tipus);
  412.             strcpy(szuromin->tipus, tipus);
  413.             strcpy(szuromax->tipus, tipus);
  414.             //voltjo = 0;
  415.             break;
  416.         }
  417.         case 'e':
  418.             system("cls");
  419.  
  420.             printf("Adjon meg egy legkorabbi evjaratot!\n");
  421.             scanmin = scanf("%d%*c", &minval);
  422.             pufferCheck(scanmin);
  423.  
  424.             printf("Adjon meg egy legkesobbi evjaratot!\n");
  425.             scanmax = scanf("%d%*c", &maxval);
  426.             pufferCheck(scanmax);
  427.  
  428.             writeFilters(&scanmin, &scanmax, &minval, &maxval, filter, &szuromin, &szuromax);
  429.  
  430.             //voltjo = 0;
  431.             break;
  432.         case 's':
  433.             system("cls");
  434.             printf("Adjon meg egy szint!\n");
  435.  
  436.             char szin[7 + 1];
  437.             scanf("%s%*c", szin);
  438.  
  439.             strcpy(szuromin->szin, szin);
  440.             strcpy(szuromax->szin, szin);
  441.  
  442.             //voltjo = 0;
  443.             break;
  444.         case 'u':
  445.             system("cls");
  446.             printf("Adja meg a ferohelyek szamat! 5/7\n");
  447.  
  448.             int ferohely;
  449.             scanf("%d%*c", &ferohely);
  450.  
  451.             szuromin->ferohely = ferohely;
  452.             szuromax->ferohely = ferohely;
  453.  
  454.             //voltjo = 0;
  455.             break;
  456.         case 'h':
  457.             system("cls");
  458.  
  459.             printf("Adja meg a minimum hengerurtartalmat!\n");
  460.             scanmin = scanf("%d%*c", &minval);
  461.             pufferCheck(scanmin);
  462.  
  463.             printf("Adja meg a maximum hengerurtartalmat!\n");
  464.             scanmax = scanf("%d%*c", &maxval);
  465.             pufferCheck(scanmax);
  466.  
  467.             writeFilters(&scanmin, &scanmax, &minval, &maxval, filter, &szuromin, &szuromax);
  468.  
  469.             //voltjo = 0;
  470.             break;
  471.         case 'l':
  472.             system("cls");
  473.  
  474.             printf("Adja meg a minimum teljesitmenyt!\n");
  475.             scanmin = scanf("%d%*c", &minval);
  476.             pufferCheck(scanmin);
  477.  
  478.             printf("Adja meg a maximum teljesitmenyt!\n");
  479.             scanmax = scanf("%d%*c", &maxval);
  480.             pufferCheck(scanmax);
  481.  
  482.             writeFilters(&scanmin, &scanmax, &minval, &maxval, filter, &szuromin, &szuromax);
  483.  
  484.             //voltjo = 0;
  485.             break;
  486.         case 'o':
  487.             system("cls");
  488.             printf("Adjon meg egy szarmazast!\n");
  489.  
  490.             char szarmazas[7 + 1];
  491.             scanf("%s%*c", szarmazas);
  492.  
  493.             strcpy(szuromin->szarmazas, szarmazas);
  494.             strcpy(szuromax->szarmazas, szarmazas);
  495.  
  496.             //voltjo = 0;
  497.             break;
  498.         case 'k':
  499.             system("cls");
  500.  
  501.             printf("Adja meg a minimum kilometerorallast!\n");
  502.             scanmin = scanf("%d%*c", &minval);
  503.             pufferCheck(scanmin);
  504.  
  505.             printf("Adja meg a maximum kilometerorallast!\n");
  506.             scanmax = scanf("%d%*c", &maxval);
  507.             pufferCheck(scanmax);
  508.  
  509.             writeFilters(&scanmin, &scanmax, &minval, &maxval, filter, &szuromin, &szuromax);
  510.  
  511.             //voltjo = 0;
  512.             break;
  513.         case 'c':
  514.             system("cls");
  515.             printf("Adja meg az elfogadhato hibakodokat! 0-5\n");
  516.  
  517.             int hibakod;
  518.             scanf("%d%*c", &hibakod);
  519.  
  520.             szuromin->hibakod = hibakod;
  521.             szuromax->hibakod = hibakod;
  522.  
  523.             //voltjo = 0;
  524.             break;
  525.         case 'a':
  526.             system("cls");
  527.             printf("Adja meg a kivant allapotot! 1-5\n");
  528.  
  529.             int allapot;
  530.             scanf("%d%*c", &allapot);
  531.  
  532.             szuromin->allapot = allapot;
  533.             szuromax->allapot = allapot;
  534.  
  535.             //voltjo = 0;
  536.             break;
  537.         case 'f':
  538.             system("cls");
  539.             printf("Adja meg, hogy elado autot keres-e! 0-1\n");
  540.  
  541.             int elado;
  542.             scanf("%d%*c", &elado);
  543.  
  544.             szuromin->elado = elado;
  545.             szuromax->elado = elado;
  546.  
  547.             //voltjo = 0;
  548.             break;
  549.         case 'p':
  550.             system("cls");
  551.  
  552.             printf("Adja meg a minimum arat!\n");
  553.             scanmin = scanf("%d%*c", &minval);
  554.             pufferCheck(scanmin);
  555.  
  556.             printf("Adja meg a maximum arat!\n");
  557.             scanmax = scanf("%d%*c", &maxval);
  558.             pufferCheck(scanmax);
  559.  
  560.             writeFilters(&scanmin, &scanmax, &minval, &maxval, filter, &szuromin, &szuromax);
  561.  
  562.             //voltjo = 0;
  563.             break;
  564.         case 'x': //ha x-et kapunk, akkor a voltjot 1-re modositjuk, kilepunk a do while ciklusbol
  565.             voltjo = 1;
  566.             break;
  567.         default: //ha egyik eset sem fut le, a bevitt karater nem megfelelo
  568.             printf
  569.             (
  570.                 "Hibas bevitt karakter!\n"
  571.                 "Usson entert az ujra valasztashoz!"
  572.             );
  573.  
  574.             getchar();
  575.         }
  576.     } while (voltjo != 1);
  577. }
  578.  
  579. //fuggveny, mely kiir egy kis udvozlo abrat indulaskor
  580. void printLogo()
  581. {
  582.     //abra es udvozloszoveg kiirasa
  583.     printf
  584.     (
  585.         "                                                                                                                                                      \n"
  586.         "                                              ``````ooooooooooooMMMMMoooooooooo````                                                                   \n"
  587.         "                                      ````ssssMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNMMMMMMsss``                                                              \n"
  588.         "                              ````ssssMMMMMMMMMMMMMMMNNNNNMM++++++++         +++++NNNMMMss``                                                          \n"
  589.         "                       ````sssMMMMMMMMMMMMMMMMMMNN+++     NM`                        +oMMMMMss``                                                      \n"
  590.         "                ...yyyyMMMMMMMMMMMMMMMMMMMMMMm//           MM                        yMMMMMmMMMMyy.                                                   \n"
  591.         "         ...yyyyMMMMMMMMMMMMMMMMMMMMMMMMMMMMm              /My                       MMMMMM //mmMMMyy..                                               \n"
  592.         "       .yMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMyyyyyyyyyyyyyyyyMMyyyyyyyyyyyyyyyyyyyyyyyMMMMMMyyyyyMMMMMMMyyyyyyyyyyyyyyy..........                      \n"
  593.         "      yMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMyyyyyy-----           \n"
  594.         "     -MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMddddddMMMMMMMMMMdddddddMMMMMMMMMMddddddMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMhhh---     \n"
  595.         "     MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM-    -MMMMMMMMMM-     -MMMMMMMMMM-   --MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMh    \n"
  596.         "     MMMMMMMMMMMMMMMMMMMMMMMMMMMddddddMMMMMMMMMMMMMMMMMMMh   :MMMMMMMMMM:  -  :MMMMMMMMMM:  -MMMMMMMMMMMMMMMMMMMMMMMMMMMMMdddddddMMMMMMMMMMMMMMMMM-   \n"
  597.         "    :MMMMMMMMMMMMMMMMMMMMMMMhooMddddddMoohMMMMMMMMMMMMMMMMd   -MMMMMMMM-  :M   -MMMMMMMM-   MMMMMMMMMMMMMMMMMMMMMMMMMMhhoodddddddoohhMMMMMMMMMMMMMM   \n"
  598.         "   dMMMMMMMMMMMMMMMMMMMMMh-odMMMMhhhMMMMMdohMMMMMMMMMMMMMMMd   hMMMMMM-   MMd   -MMMMMMh   dMMMMMMMMMMMMMMMMMMMMMMMMhoddMMMMhhhMMMMddohMMMMMMMMMMMM   \n"
  599.         "   MMMMMMMMMMMMMMMMMMMMMh:dMMhh--   ---hMMMd-MMMMMMMMMMMMMMMd   hMMMMh   dMMMd   hMMMMh   dMMMMMMMMMMMMMMMMMMMMMMMM-dMMMh---   --hhMMM:hMMMMMMMMMMM   \n"
  600.         "   -MMMMMMMMMMMMMMMMMMMy/MMMy           -yMMd-MMMMMMMMMMMMMMMd   yMMy   dMMMMMd   yMMy   dMMMMMMMMMMMMMMMMMMMMMMMM-dMMM-           -MMM/-MMMMMMMMMMd  \n"
  601.         "    yMMMMMMMMMMMMMMMMMy MMMy              MMMm.MMMMMMMMMMMMMMM/   MM   /MMMMMMM/   MM   mMMMMMMMMMMMMMMMMMMMMMMMM.mMMM.             yMMM yMMMMMMMMM.  \n"
  602.         "     yyMMMMMMMMMMMMMMM  MMM               MMMM .MMMMMMMMMMMMMMM/  ..  /MMMMMMMMM/  ..  /MMMMMMMMMMMMMMMMMMMMMMMM. MMMM               MMM  yMMMMM...   \n"
  603.         "       ...yyyyyyyyMMM.  MMM/              MMMM  yMMMMMMMMMMMMMMM      MMMMMMMMMMM      MMMMMMMMMMMMMMMMMMMMMMMMM  MMMM              /MMM   MMMMMmm    \n"
  604.         "                  ```   sMMM+            NMMM`   MMMMMMMMMMMMMMM++++++MMMMMMMMMMM++++++MMMMMMMMMMMMMMMMMMMMMMMM`  `MMMN            +MMMs   MMMMMs`    \n"
  605.         "                         sMMMN+        +NMMM`    ``````````````````````````````````````````````````````````````    `MMMN++       ++MMMs    `````      \n"
  606.         "                          `sMMMNNNNNNNNMMMs`                                                                        `sMMMMNNN+NNNMMMs`                \n"
  607.         "                            `ooMMMMMMMoo``                                                                            ``ooMMMMMMMoo`                  \n"
  608.         "                                                                                                                                                      \n"
  609.     );
  610.     printf("Wheelmos es Tarsa\n");
  611.     printf("Gepjarmu nyilvantarto szoftver\n");
  612.     printf("Usson entert a folyatatshoz!\n");
  613.     getchar();
  614.     system("cls");
  615. }
  616.  
  617. //////////////////////////////main//////////////////////////////
  618. int main()
  619. {
  620.     jarmu szuroreset = { "-","-","-",-1,"-",-1,-1,-1,"-",-1,-1,-1,-1,-1 }; //a szurokben talalhato ertekek alapbol ezeketet az ertekeket veszik fel
  621.     jarmu szuromin = szuroreset; //a kiindulási helyzetben a min es max szuro is ezzel egyenlo
  622.     jarmu szuromax = szuroreset;
  623.  
  624.     //lista letrehozasa es feltoltese
  625.     listelem *list = NULL;
  626.  
  627.     //a ket file pointer letrehozasa
  628.     FILE* adatok;
  629.     FILE* jellemzok;
  630.  
  631.     //fileok megnyitasa olvasara
  632.     adatok = fopen("adatok.txt", "r");
  633.     jellemzok = fopen("jellemzok.txt", "r");
  634.  
  635.     //ha valamelyik file olvasasa sikertelen, hibauzenet, visszateres
  636.     if (adatok == NULL || jellemzok == NULL)
  637.     {
  638.         printf
  639.         (   "Hiba!\n"
  640.             "Valamelyik file olvasasa sikertelen.\n"
  641.             "A folytatashoz nyomjon egy billenyut!\n"
  642.         );
  643.         return -1;
  644.     }
  645.  
  646.     jarmu read; //atmeneti a valtozo egy-egy sor adatanak tarolasahoz
  647.  
  648.     //az adatok beolvasasa a fileokba
  649.     while ((fscanf(adatok, "%s\t%s\t%s\t%d\t%s\t%d\t%d\t%d", read.rendszam, read.gyarto, read.tipus, &read.evjarat, read.szin, &read.ferohely, &read.hengerur, &read.teljesitmeny) == 8) && (fscanf(jellemzok, "%s\t%s\t%d\t%d\t%d\t%d\t%d", read.rendszam, read.szarmazas, &read.kilometer, &read.hibakod, &read.allapot, &read.elado, &read.ar) == 7))
  650.     {
  651.         list = beszurHatra(list, read);
  652.     }
  653.  
  654.     //fileok bezarasa a hasznalat utan
  655.     fclose(adatok);
  656.     fclose(jellemzok);
  657.  
  658.     //printf("Az adatok olvasasa sikeresen megtortent!");
  659.     //kiirMindet(list);
  660.  
  661.     //cls a biztonsag kedveert
  662.     system("cls");
  663.  
  664.     while (1) //ide kerul a foprogram
  665.     {
  666.         //fomenu kiirasa
  667.         char select;
  668.  
  669.         system("cls");
  670.  
  671.         printf
  672.         (
  673.             "Menu:\n"          
  674.             "o: Osszes adat kiirasa\n"
  675.             "u: uj szuro hozaadasa\n"
  676.             "s: szurt adatok kiirasa\n"
  677.             "j: jelenleg aktiv szurok kiirasa\n"
  678.             "t: minden szuro torelese\n"
  679.             "x: Kilepes\n"
  680.         );
  681.  
  682.         //menupont kivalasztasa
  683.         scanf("%c%*c", &select);
  684.  
  685.         switch (select)
  686.         {
  687.         case 'o': //az osszes adat kiirasa
  688.             system("cls"); //console-on levo kiirt adatok torlese
  689.             kiirMindet(list); //minden adat kiirasa
  690.             printf("A kilepehez usson entert!\n");
  691.             getchar(); //varakozas a felhasznalo valaszara
  692.             break;
  693.  
  694.         case 'x': //kilepes
  695.             system("cls");
  696.             printf("Biztosan kilep? i/n\n");
  697.             char exit;
  698.             scanf("%c%*c", &exit); //megerosites kerese a kilepeshez (barmilyen i-tol kulonbozo karakter esetén visszalepunk a menube)
  699.             if(exit == 'i') //ha i a bevitt karakter, akkor a program leall
  700.             {
  701.                 felszabadit(list);
  702.                 //getchar();
  703.                 return 0;
  704.             }          
  705.             break;
  706.  
  707.         case 'u': //uj szuro felvetele
  708.         {
  709.             create_new_filter(&szuromin, &szuromax);
  710.             break;
  711.         }
  712.  
  713.         case 's': //szurt adatok kiirasa
  714.         {
  715.             system("cls");
  716.  
  717.             listelem *p = list; //pointer letrehozasa a lepteteshez
  718.             int kiiras = 0; //valtozo a kiiras sikeressegenek ellenorzesehez
  719.  
  720.             while (p->next != NULL) //amig el nem erunk a lista vegere, addig megyünk
  721.             {
  722.                 if (szures(p, &szuromin, &szuromax) == 1) //ha az adott listaelem a szuroknek megfelel
  723.                 {
  724.                     kiirSort(p); //kiirjuk az adott sort
  725.                     kiiras = 1;
  726.                 }
  727.                 p = p->next; //es tovabb lepunk
  728.             }
  729.             if (kiiras == 0) //ha nem sikerult kiiirni semmit
  730.             {
  731.                 printf("Nincs talalat."); //kiirjuk, hogy nincs talalat
  732.             }
  733.  
  734.             printf("A visszalepehez usson entert!\n");
  735.  
  736.             getchar();
  737.             break;
  738.         }
  739.  
  740.         case 'j':
  741.             system("cls");
  742.  
  743.             printf("Jelenleg beallitott szurok:\n");
  744.  
  745.             kiirSort(&szuromin);
  746.             kiirSort(&szuromax);
  747.  
  748.             getchar();
  749.             break;
  750.  
  751.         case 't': //a t menupontban minden beallitott szuro torlesre kerul
  752.         {
  753.             system("cls");
  754.             szuromin = szuroreset;//az eddigi szuroket az alap 'reset' szurore allitjuk vissza
  755.             szuromax = szuroreset;
  756.             printf
  757.             (
  758.                 "Minden szuro torolve.\n"
  759.                 "Usson entert a visszalepeshez!\n"
  760.             );
  761.             getchar();
  762.             break;
  763.         }
  764.  
  765.         default: //ha egyik eset sem fut le, a bevitt karakter nem megfelelo
  766.             printf
  767.             (
  768.                 "Hibas bevitt karakter!\n"
  769.                 "Usson entert az ujra valasztashoz!"
  770.             );
  771.             getchar();
  772.         }
  773.     }
  774.  
  775. return 0;
  776. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement