gepjaramunyilvantartas

//*****************************************//
//---Gépjármű nyilvántartó szoftver    ---//
//---Megbízó: Wheelmos és Társa Kft.    ---//
//---Készítette: Tószegi Máté          ---//
//---Dátum: 2019.12.08                 ---//
//*****************************************//

//megjegyzes: a megvalositas soran strazsa nelkuli listat alkalmazunk

#include <stdio.h>
//#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <limits.h>

//a jarmu struktura definialasa
typedef struct jarmu
{
    //adatok
    char rendszam[7 + 1];
    char gyarto[7 + 1];
    char tipus[7 + 1];
    int evjarat;
    char szin[7 + 1];
    int ferohely;
    int hengerur;
    int teljesitmeny;

    //jellemzok
    char szarmazas[7 + 1];
    int kilometer;
    int hibakod;
    int allapot;
    int elado;
    int ar;
}jarmu;

//egy listaelem definialasa
typedef struct listelem
{
    jarmu data;
    struct listelem* next;

}listelem;

//fuggveny a hatra beszurashoz, ket bemeno parametere
listelem* beszurHatra(listelem* list, jarmu data)
{
    if (list == NULL) //ha ures a lista, akkor felepitjuk az első elemet
    {
        listelem* uj = (listelem*)malloc(sizeof(listelem));
        uj->next = NULL;
        uj->data = data;
        return uj;
    }
    else //egyebkent beszurunk a vegere
    {
        listelem* p = list;
        while (p->next != NULL)
        {
            p = p->next;
        }

        listelem* uj = (listelem*)malloc(sizeof(listelem));
        uj->next = NULL;
        uj->data = data;
        p->next = uj;
        return list;

    }
}


//fuggveny, mely megadja, hogy egy adott elem megfelel-e a szuresi parametereknek
//visszaeteresi erteke 1, ha megfelel, 0, ha nem felel meg az adott elem
//elso ranezesre tobb fuggvenyre lehene bontani azonban az adattipusok elterese es a kezelesuk egyszerubbe teszi a jelnlegi fuggveny hasznalatat
int szures(jarmu *p, jarmu *szuromin, jarmu *szuromax)
{
    int jo = 1;

    if (strcmp(szuromin->rendszam, "-") != 0)
    {
        if (strcmp(szuromin->rendszam, p->rendszam) != 0)
        {
            jo = 0;
        }
    }

    if (strcmp(szuromin->gyarto, "-") != 0)
    {
        if (strcmp(szuromin->gyarto, p->gyarto) != 0)
        {
            jo = 0;
        }
    }

    if (strcmp(szuromin->tipus, "-") != 0)
    {
        if (strcmp(szuromin->tipus, p->tipus) != 0)
        {
            jo = 0;
        }
    }

    if (szuromin->evjarat != -1)
    {
        if (szuromin->evjarat > p->evjarat || szuromax->evjarat < p->evjarat)
        {
            jo = 0;
        }
    }

    if (strcmp(szuromin->szin, "-") != 0)
    {
        if (strcmp(szuromin->szin, p->szin) != 0)
        {
            jo = 0;
        }
    }

    if (szuromin->ferohely != -1)
    {
        if (szuromin->ferohely != p->ferohely)
        {
            jo = 0;
        }
    }

    if (szuromin->hengerur != -1)
    {
        if (szuromin->hengerur > p->hengerur || szuromax->hengerur < p->hengerur)
        {
            jo = 0;
        }
    }

    if (szuromin->teljesitmeny != -1)
    {
        if (szuromin->teljesitmeny > p->teljesitmeny || szuromax->teljesitmeny < p->teljesitmeny)
        {
            jo = 0;
        }
    }

    if (strcmp(szuromin->szarmazas, "-") != 0)
    {
        if (strcmp(szuromin->szarmazas, p->szarmazas) != 0)
        {
            jo = 0;
        }
    }

    if (szuromin->kilometer != -1)
    {
        if (szuromin->kilometer > p->kilometer || szuromax->kilometer < p->kilometer)
        {
            jo = 0;
        }
    }

    if (szuromin->hibakod != -1)
    {
        if (szuromin->hibakod != p->hibakod)
        {
            jo = 0;
        }
    }

    if (szuromin->allapot != -1)
    {
        if (szuromin->allapot != p->allapot)
        {
            jo = 0;
        }
    }

    if (szuromin->elado != -1)
    {
        if (szuromin->elado != p->elado)
        {
            jo = 0;
        }
    }

    if (szuromin->ar != -1)
    {
        if (szuromin->ar > p->ar || szuromax->ar < p->ar)
        {
            jo = 0;
        }
    }
    return jo;
}

//fuggveny, mely a lista minden elemet kiirja
void kiirMindet(listelem* list)
{
    listelem* p = list;
    while (p != NULL)
    {
        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);

        if (p->data.elado == 1)
        {
            printf("%d\n", p->data.ar);
        }
        else
        {
            printf("\n");
        }

        p = p->next;
    }


}

//kiiro fuggveny, egy adott sor adatat irja ki adott listabol
void kiirSort(listelem *p)
{
    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);

    if (p->data.elado == 1)
    {
        printf("%d\n", p->data.ar);
    }
    else
    {
        printf("\n");
    }
}

//fuggveny, mely megnezi, hogy elozoleg sikeres volt-e a beolvasas a konzolrol
//ha nem, akkor a 2db gethar a felesleges karaktereket beolvassa, ezzel uritve a bemeneti puffert
void pufferCheck(int in)
{
    if (in == 0)
    {
        getchar(); //az elozo x-bevitelt lekezeljuk, beolvassuk ahz x-ez majd az utana levo szokozt
        getchar();
    }
}

//fuggveny, mely lekezeli az olyan eseteket, melyeknek also/felso hatarertek is beviheto
//scanmin es scanmax: sikerult-e max illetve min erteket olvasni
//minval es maxval: a felhasznalo altal bevitt max es min erteke
//szuromin, szuromax:  a modositando elemek cimei
void minmaxWrite(int *scanmin, int *scanmax, int *minval, int *maxval, int *szuromin, int *szuromax)
{
    if (*scanmax == 0)
    {
        *szuromax = INT_MAX;
    }
    else
    {
        *szuromax = *maxval;
    }

    if (*scanmin == 0)
    {
        *szuromin = INT_MIN;
    }
    else
    {
        *szuromin = *minval;
    }
}


//fuggveny, mely a bevitt ertekeket beirja a min es max strukturaba, de csak azokban az esetekben, ahol erre a hatarertekes szuresre lehetoseg van
//bemeno parameterei  a minmaxWrite() fuggvenyhez hasonloak
void writeFilters(int *scanmin, int *scanmax, int *minval, int *maxval, char item, jarmu *szuromin, jarmu *szuromax)
{
    switch(item)
    {
        case 'r':
            break;
        case 'g':
            break;
        case 't':
            break;
        case 'e':
            minmaxWrite(scanmin, scanmax, minval, maxval, &szuromin->evjarat, &szuromax->evjarat);
            break;
        case 's':
            break;
        case 'u':
            break;
        case 'h':
            minmaxWrite(scanmin, scanmax, minval, maxval, &szuromin->hengerur, &szuromax->hengerur);
            /*if (*scanmax == 0)
            {
                szuromax->hengerur = INT_MAX;
            }
            else
            {
                szuromax->hengerur = *maxval;
            }

            if (*scanmin == 0)
            {
                szuromin->hengerur = INT_MIN;
            }
            else
            {
                szuromin->hengerur = *minval;
            }*/
            break;
        case 'l':
            minmaxWrite(scanmin, scanmax, minval, maxval, &szuromin->teljesitmeny, &szuromax->teljesitmeny);
            break;
        case 'o':
            break;
        case 'k':
            minmaxWrite(scanmin, scanmax, minval, maxval, &szuromin->kilometer, &szuromax->kilometer);
            break;
        case 'c':
            break;
        case 'a':
            break;
        case 'f':
            break;
        case 'p':
            minmaxWrite(scanmin, scanmax, minval, maxval, &szuromin->ar, &szuromax->ar);
            break;
    }
}

//felszabadito fuggveny, az egesz listat torli a memoriabol
void felszabadit(listelem *list)
{
    while (list != NULL)
    {
        listelem *next = list->next; //eltaroljuk kulon valtozoban a kovetkezo elem cimet, hiszen az elso elem torlesevel nem tudnank elerni a lista tobbi elemet
        free(list);
        //printf("%p felszabadtva\n", list);
        list = next;
    }
}


//fuggveny uj szuro felvetelehez
//bemenoparameteri a max es min strukturak cimei, ezekbe ir
void create_new_filter(jarmu *szuromin, jarmu *szuromax)
{
    int voltjo = 0;
    do //addig maradunk a menuben, amig nem x karakter erkezik, ezt a switch-case figyeli
    {
        system("cls");

        int scanmin = 1;
        int scanmax = 1;
        int maxval = INT_MIN;
        int minval = INT_MAX;

        printf//a szurok menu kiirasa
        (
            "Szuro beallitasa:\n"
            "(Valassza ki mire szeretne szurni)\n"
            "r: rendszam\n"
            "g: gyarto\n"
            "t: tipus\n"
            "e: evjarat\n"
            "s: szin\n"
            "u: ulohelyek szama\n"
            "h: hengerurtaralom\n"
            "l: teljesitmeny(le)\n"
            "o: szarmazas (origin)\n"
            "k: kilometeroraallas\n"
            "c: hibakod (code)\n"
            "a: allapot\n"
            "f: elado(for sale)\n"
            "p: ar(price)\n"
            "x: visszalepes a fomenube\n"
        );
        char filter;
        scanf("%c%*c", &filter); //szuro karakter bekerese
        switch (filter)
        {
        case 'r': //ha r, akkor rendszamra szurunk
            system("cls");

            printf("Adjon meg egy rendszamot!\n");
            char rendszam[7 + 1];
            scanf("%s%*c", rendszam);

            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
            strcpy(szuromax->rendszam, rendszam);

            //voltjo = 0; //0-ra állítjuk, hogy benne maradjunk a ciklusban (nem lenne szukseges, de igy biztonsagosabb),
            break;
        case 'g':
        {
            system("cls");
            printf("Adjon meg egy gyartot!\n");

            char gyarto[7 + 1];
            scanf("%s%*c", gyarto);

            strcpy(szuromin->gyarto, gyarto);
            strcpy(szuromax->gyarto, gyarto);

            //voltjo = 0;
            break;
        }
        case 't':
        {
            system("cls");
            printf("Adjon meg egy tipust!\n");
            char tipus[7 + 1];
            scanf("%s%*c", tipus);
            strcpy(szuromin->tipus, tipus);
            strcpy(szuromax->tipus, tipus);
            //voltjo = 0;
            break;
        }
        case 'e':
            system("cls");

            printf("Adjon meg egy legkorabbi evjaratot!\n");
            scanmin = scanf("%d%*c", &minval);
            pufferCheck(scanmin);

            printf("Adjon meg egy legkesobbi evjaratot!\n");
            scanmax = scanf("%d%*c", &maxval);
            pufferCheck(scanmax);

            writeFilters(&scanmin, &scanmax, &minval, &maxval, filter, &szuromin, &szuromax);

            //voltjo = 0;
            break;
        case 's':
            system("cls");
            printf("Adjon meg egy szint!\n");

            char szin[7 + 1];
            scanf("%s%*c", szin);

            strcpy(szuromin->szin, szin);
            strcpy(szuromax->szin, szin);

            //voltjo = 0;
            break;
        case 'u':
            system("cls");
            printf("Adja meg a ferohelyek szamat! 5/7\n");

            int ferohely;
            scanf("%d%*c", &ferohely);

            szuromin->ferohely = ferohely;
            szuromax->ferohely = ferohely;

            //voltjo = 0;
            break;
        case 'h':
            system("cls");

            printf("Adja meg a minimum hengerurtartalmat!\n");
            scanmin = scanf("%d%*c", &minval);
            pufferCheck(scanmin);

            printf("Adja meg a maximum hengerurtartalmat!\n");
            scanmax = scanf("%d%*c", &maxval);
            pufferCheck(scanmax);

            writeFilters(&scanmin, &scanmax, &minval, &maxval, filter, &szuromin, &szuromax);

            //voltjo = 0;
            break;
        case 'l':
            system("cls");

            printf("Adja meg a minimum teljesitmenyt!\n");
            scanmin = scanf("%d%*c", &minval);
            pufferCheck(scanmin);

            printf("Adja meg a maximum teljesitmenyt!\n");
            scanmax = scanf("%d%*c", &maxval);
            pufferCheck(scanmax);

            writeFilters(&scanmin, &scanmax, &minval, &maxval, filter, &szuromin, &szuromax);

            //voltjo = 0;
            break;
        case 'o':
            system("cls");
            printf("Adjon meg egy szarmazast!\n");

            char szarmazas[7 + 1];
            scanf("%s%*c", szarmazas);

            strcpy(szuromin->szarmazas, szarmazas);
            strcpy(szuromax->szarmazas, szarmazas);

            //voltjo = 0;
            break;
        case 'k':
            system("cls");

            printf("Adja meg a minimum kilometerorallast!\n");
            scanmin = scanf("%d%*c", &minval);
            pufferCheck(scanmin);

            printf("Adja meg a maximum kilometerorallast!\n");
            scanmax = scanf("%d%*c", &maxval);
            pufferCheck(scanmax);

            writeFilters(&scanmin, &scanmax, &minval, &maxval, filter, &szuromin, &szuromax);

            //voltjo = 0;
            break;
        case 'c':
            system("cls");
            printf("Adja meg az elfogadhato hibakodokat! 0-5\n");

            int hibakod;
            scanf("%d%*c", &hibakod);

            szuromin->hibakod = hibakod;
            szuromax->hibakod = hibakod;

            //voltjo = 0;
            break;
        case 'a':
            system("cls");
            printf("Adja meg a kivant allapotot! 1-5\n");

            int allapot;
            scanf("%d%*c", &allapot);

            szuromin->allapot = allapot;
            szuromax->allapot = allapot;

            //voltjo = 0;
            break;
        case 'f':
            system("cls");
            printf("Adja meg, hogy elado autot keres-e! 0-1\n");

            int elado;
            scanf("%d%*c", &elado);

            szuromin->elado = elado;
            szuromax->elado = elado;

            //voltjo = 0;
            break;
        case 'p':
            system("cls");

            printf("Adja meg a minimum arat!\n");
            scanmin = scanf("%d%*c", &minval);
            pufferCheck(scanmin);

            printf("Adja meg a maximum arat!\n");
            scanmax = scanf("%d%*c", &maxval);
            pufferCheck(scanmax);

            writeFilters(&scanmin, &scanmax, &minval, &maxval, filter, &szuromin, &szuromax);

            //voltjo = 0;
            break;
        case 'x': //ha x-et kapunk, akkor a voltjot 1-re modositjuk, kilepunk a do while ciklusbol
            voltjo = 1;
            break;
        default: //ha egyik eset sem fut le, a bevitt karater nem megfelelo
            printf
            (
                "Hibas bevitt karakter!\n"
                "Usson entert az ujra valasztashoz!"
            );

            getchar();
        }
    } while (voltjo != 1);
}

//fuggveny, mely kiir egy kis udvozlo abrat indulaskor
void printLogo()
{
    //abra es udvozloszoveg kiirasa
    printf
    (
        "                                                                                                                                                      \n"
        "                                              ``````ooooooooooooMMMMMoooooooooo````                                                                   \n"
        "                                      ````ssssMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNMMMMMMsss``                                                              \n"
        "                              ````ssssMMMMMMMMMMMMMMMNNNNNMM++++++++         +++++NNNMMMss``                                                          \n"
        "                       ````sssMMMMMMMMMMMMMMMMMMNN+++     NM`                        +oMMMMMss``                                                      \n"
        "                ...yyyyMMMMMMMMMMMMMMMMMMMMMMm//           MM                        yMMMMMmMMMMyy.                                                   \n"
        "         ...yyyyMMMMMMMMMMMMMMMMMMMMMMMMMMMMm              /My                       MMMMMM //mmMMMyy..                                               \n"
        "       .yMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMyyyyyyyyyyyyyyyyMMyyyyyyyyyyyyyyyyyyyyyyyMMMMMMyyyyyMMMMMMMyyyyyyyyyyyyyyy..........                      \n"
        "      yMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMyyyyyy-----           \n"
        "     -MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMddddddMMMMMMMMMMdddddddMMMMMMMMMMddddddMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMhhh---     \n"
        "     MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM-    -MMMMMMMMMM-     -MMMMMMMMMM-   --MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMh    \n"
        "     MMMMMMMMMMMMMMMMMMMMMMMMMMMddddddMMMMMMMMMMMMMMMMMMMh   :MMMMMMMMMM:  -  :MMMMMMMMMM:  -MMMMMMMMMMMMMMMMMMMMMMMMMMMMMdddddddMMMMMMMMMMMMMMMMM-   \n"
        "    :MMMMMMMMMMMMMMMMMMMMMMMhooMddddddMoohMMMMMMMMMMMMMMMMd   -MMMMMMMM-  :M   -MMMMMMMM-   MMMMMMMMMMMMMMMMMMMMMMMMMMhhoodddddddoohhMMMMMMMMMMMMMM   \n"
        "   dMMMMMMMMMMMMMMMMMMMMMh-odMMMMhhhMMMMMdohMMMMMMMMMMMMMMMd   hMMMMMM-   MMd   -MMMMMMh   dMMMMMMMMMMMMMMMMMMMMMMMMhoddMMMMhhhMMMMddohMMMMMMMMMMMM   \n"
        "   MMMMMMMMMMMMMMMMMMMMMh:dMMhh--   ---hMMMd-MMMMMMMMMMMMMMMd   hMMMMh   dMMMd   hMMMMh   dMMMMMMMMMMMMMMMMMMMMMMMM-dMMMh---   --hhMMM:hMMMMMMMMMMM   \n"
        "   -MMMMMMMMMMMMMMMMMMMy/MMMy           -yMMd-MMMMMMMMMMMMMMMd   yMMy   dMMMMMd   yMMy   dMMMMMMMMMMMMMMMMMMMMMMMM-dMMM-           -MMM/-MMMMMMMMMMd  \n"
        "    yMMMMMMMMMMMMMMMMMy MMMy              MMMm.MMMMMMMMMMMMMMM/   MM   /MMMMMMM/   MM   mMMMMMMMMMMMMMMMMMMMMMMMM.mMMM.             yMMM yMMMMMMMMM.  \n"
        "     yyMMMMMMMMMMMMMMM  MMM               MMMM .MMMMMMMMMMMMMMM/  ..  /MMMMMMMMM/  ..  /MMMMMMMMMMMMMMMMMMMMMMMM. MMMM               MMM  yMMMMM...   \n"
        "       ...yyyyyyyyMMM.  MMM/              MMMM  yMMMMMMMMMMMMMMM      MMMMMMMMMMM      MMMMMMMMMMMMMMMMMMMMMMMMM  MMMM              /MMM   MMMMMmm    \n"
        "                  ```   sMMM+            NMMM`   MMMMMMMMMMMMMMM++++++MMMMMMMMMMM++++++MMMMMMMMMMMMMMMMMMMMMMMM`  `MMMN            +MMMs   MMMMMs`    \n"
        "                         sMMMN+        +NMMM`    ``````````````````````````````````````````````````````````````    `MMMN++       ++MMMs    `````      \n"
        "                          `sMMMNNNNNNNNMMMs`                                                                        `sMMMMNNN+NNNMMMs`                \n"
        "                            `ooMMMMMMMoo``                                                                            ``ooMMMMMMMoo`                  \n"
        "                                                                                                                                                      \n"
    );
    printf("Wheelmos es Tarsa\n");
    printf("Gepjarmu nyilvantarto szoftver\n");
    printf("Usson entert a folyatatshoz!\n");
    getchar();
    system("cls");
}

//////////////////////////////main//////////////////////////////
int main()
{
    jarmu szuroreset = { "-","-","-",-1,"-",-1,-1,-1,"-",-1,-1,-1,-1,-1 }; //a szurokben talalhato ertekek alapbol ezeketet az ertekeket veszik fel
    jarmu szuromin = szuroreset; //a kiindulási helyzetben a min es max szuro is ezzel egyenlo
    jarmu szuromax = szuroreset;

    //lista letrehozasa es feltoltese
    listelem *list = NULL;

    //a ket file pointer letrehozasa
    FILE* adatok;
    FILE* jellemzok;

    //fileok megnyitasa olvasara
    adatok = fopen("adatok.txt", "r");
    jellemzok = fopen("jellemzok.txt", "r");

    //ha valamelyik file olvasasa sikertelen, hibauzenet, visszateres
    if (adatok == NULL || jellemzok == NULL)
    {
        printf
        (   "Hiba!\n"
            "Valamelyik file olvasasa sikertelen.\n"
            "A folytatashoz nyomjon egy billenyut!\n"
        );
        return -1;
    }

    jarmu read; //atmeneti a valtozo egy-egy sor adatanak tarolasahoz

    //az adatok beolvasasa a fileokba
    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))
    {
        list = beszurHatra(list, read);
    }

    //fileok bezarasa a hasznalat utan
    fclose(adatok);
    fclose(jellemzok);

    //printf("Az adatok olvasasa sikeresen megtortent!");
    //kiirMindet(list);

    //cls a biztonsag kedveert
    system("cls");

    while (1) //ide kerul a foprogram
    {
        //fomenu kiirasa
        char select;

        system("cls");

        printf
        (
            "Menu:\n"
            "o: Osszes adat kiirasa\n"
            "u: uj szuro hozaadasa\n"
            "s: szurt adatok kiirasa\n"
            "j: jelenleg aktiv szurok kiirasa\n"
            "t: minden szuro torelese\n"
            "x: Kilepes\n"
        );

        //menupont kivalasztasa
        scanf("%c%*c", &select);

        switch (select)
        {
        case 'o': //az osszes adat kiirasa
            system("cls"); //console-on levo kiirt adatok torlese
            kiirMindet(list); //minden adat kiirasa
            printf("A kilepehez usson entert!\n");
            getchar(); //varakozas a felhasznalo valaszara
            break;

        case 'x': //kilepes
            system("cls");
            printf("Biztosan kilep? i/n\n");
            char exit;
            scanf("%c%*c", &exit); //megerosites kerese a kilepeshez (barmilyen i-tol kulonbozo karakter esetén visszalepunk a menube)
            if(exit == 'i') //ha i a bevitt karakter, akkor a program leall
            {
                felszabadit(list);
                //getchar();
                return 0;
            }
            break;

        case 'u': //uj szuro felvetele
        {
            create_new_filter(&szuromin, &szuromax);
            break;
        }

        case 's': //szurt adatok kiirasa
        {
            system("cls");

            listelem *p = list; //pointer letrehozasa a lepteteshez
            int kiiras = 0; //valtozo a kiiras sikeressegenek ellenorzesehez

            while (p->next != NULL) //amig el nem erunk a lista vegere, addig megyünk
            {
                if (szures(p, &szuromin, &szuromax) == 1) //ha az adott listaelem a szuroknek megfelel
                {
                    kiirSort(p); //kiirjuk az adott sort
                    kiiras = 1;
                }
                p = p->next; //es tovabb lepunk
            }
            if (kiiras == 0) //ha nem sikerult kiiirni semmit
            {
                printf("Nincs talalat."); //kiirjuk, hogy nincs talalat
            }

            printf("A visszalepehez usson entert!\n");

            getchar();
            break;
        }

        case 'j':
            system("cls");

            printf("Jelenleg beallitott szurok:\n");

            kiirSort(&szuromin);
            kiirSort(&szuromax);

            getchar();
            break;

        case 't': //a t menupontban minden beallitott szuro torlesre kerul
        {
            system("cls");
            szuromin = szuroreset;//az eddigi szuroket az alap 'reset' szurore allitjuk vissza
            szuromax = szuroreset;
            printf
            (
                "Minden szuro torolve.\n"
                "Usson entert a visszalepeshez!\n"
            );
            getchar();
            break;
        }

        default: //ha egyik eset sem fut le, a bevitt karakter nem megfelelo
            printf
            (
                "Hibas bevitt karakter!\n"
                "Usson entert az ujra valasztashoz!"
            );
            getchar();
        }
    }

return 0;
}