API tools faq
paste
Advertisement
Matqux

hazi_final

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