Simulacia vlaku – C / C++ – Fórum – Programujte.com

Prosím, nevie mi niekto povedať, prečo sa mi to vždy zacyklí? Malo by sa mi vytvoriť zoznam s 8 zásobnikmi v ktorých bude nanajvýš N prvkov...

Prikladám aj zadanie:Na malém nákladním nádraží je jedna příjezdová kolej, na které stojí vlak s M vagony (např. M = 50). Dále je na nádraží několik slepých kolejí (předpokládejme, že jejich počet není omezen. Lokomotiva je na opačné straně, než jsou nájezdy na slepé koleje. Slepé koleje slouží k dočasnému „odložení“ vagonů vlaku, který je na příjezdové koleji. Na každou slepou kolej lze „odložit“ nejvýše N vagonů (např. N = 7). Úkolem je „odložit“ dočasně všechny vagony vlaku na co nejmenší počet slepých kolejí. Poté je po nějakém čase potřeba vagony opět připojit, a to ve stejném pořadí, v jakém byly za lokomotivou pů- vodně. Principem je, že lokomotiva může opakovaně zatlačit celý vlak na jednu ze slepých kolejí, tam odpojit jeden vagon, a poté se vrátit na příjezdovou kolej. Implementace

 Čísla N, M deklarujte jako globální konstanty.

 Vlak reprezentujte jako zásobník implementovaný pomocí pole pro M vagonů, kde první vagon za lokomotivou bude na dně zásobníku a poslední vagon na vrcholu zásobníku.

 Každou slepou kolej reprezentujte zásobníkem implementovaným pomocí pole pro N vagonů. Nepoužívejte třídy (zásobníky budou reprezentovány jako struktury).

 Zásobník si bude pamatovat pořadí, ve kterém vznikl. Zásobník reprezentující vlak bude mít pořadí 0, slepé koleje pak pořadí od 1.

 Použité slepé koleje reprezentujte jako jednosměrný seznam implementovaný pomocí ukazatelů, jehož prvky jsou zásobníky. Potřebu nové slepé koleje implementujte jako vložení nového zásobníku na začátek seznamu. Připojení posledního vagonu ze slepé koleje implementujte společně s odebráním slepé koleje (zásobníku) ze seznamu.

 Prvek zásobníku implementujte jako číslo, které bude reprezentovat identifikaci vagonu (číslo typu int).

 Vytvoření vlaku na příjezdové koleji (s M vagony) reprezentujte cyklem for. V každém kroku cyklu bude vygenerován jeden vagon. Identifikátorem vagonu je pořadí, ve kterém byl vygenerován (první vagon bude mít identifikátor 1, poslední M). Průběh „odložení“ všech vagonů na slepé koleje reprezentujte cyklem while. Zpětné připojení vagonů k lokomotivě reprezentujte cykly while. Na výstupu zobrazte odděleny mezerou tyto operace:

 Vygenerování nového vagonu ve formě G#1, kde #1 je identifikace vagonu. Třetí vagon bude vytisknut ve tvaru G3.

 „Odložení“ vagonu na slepou kolej O#1[K#2], kde #1 je identifikace vagonu a #2 je pořadí slepé koleje (zásobníku). Pokud bude „odložen“ třetí vagon na druhou slepou kolej, bude na výstupu O3[K2]

 Připojení vagonu na slepé koleji zpět k vlaku ve formě P#1[K#2], kde #1 je identifikace vagonu a #2 je pořadí slepé koleje (zásobníku). Pokud bude připojen třetí vagon z druhé slepé koleje, bude na výstupu P3[K2].

#include<iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

unsigned int const M = 50;                          //počet vagonov pre lokomotivu

unsigned int const N = 7;                          //počet vagónov na 1 slepú koľaj


struct Vagon{   //vozík vagónu
    //Identifikator vagonu: 1 - první vagon pøi prvním zapojení atd až M
    unsigned int    id;
};

struct Zasobnik{   //zásobník
    Vagon Data[M];
    int SP;

};


struct Zoznam
{
    Zasobnik data;
    Zoznam* dalsi;

};
void Init(Zasobnik& S){    //Inicializace zásobníku.
    //stack pointer - aktuální pozice zásobníku je na nule
    S.SP = 0;
}


void Clear(Zasobnik& S){   //Smaž zasobnik
    //zmìní Stack pointer na nulu - nemusí se všechny položky mazat, jednoduše se pak akorat vždy pøepišou
    S.SP = 0;
}


void Push(Zasobnik& S, const Vagon & X){  //Vložení prvku do zásobníku
    //vložení hodnoty X do zásobníku na pozici kterou ukazuje stack pointer
    S.Data[S.SP] = X;

    //navýšení stack pointeru
    S.SP += 1;
}

Vagon Pop(Zasobnik& S){     //vyjmutí vrchního prvku ze zásobníku
    //snižení stack pointeru o 1
    S.SP -= 1;

    //vypsaní nejvyššího prvku returnem
    return S.Data[S.SP];
}


Vagon Look(Zasobnik& S){     //zobrazení vrchního prvku ze zásobníku bez smazání
    //vypsaní nejvyššího prvku returnem
    return S.Data[S.SP-1];
}

bool IsEmpty(const Zasobnik& S){   //kontrola zda zásobník je prázdny
    //pokud stack pointer má hodnotu 0 tak vyhodi returnem true - prázdný zásobník
    return S.SP == 0;
}

bool IsEmptyN(const Zasobnik& S){   //kontrola zda zásobník je prázdny
    //pokud stack pointer má hodnotu 0 tak vyhodi returnem true - prázdný zásobník
    return S.SP == 0;
}

bool IsFull(const Zasobnik& S){   //kontrola zda zásobník je prázdny
    //pokud stack pointer má hodnotu 0 tak vyhodi returnem true - prázdný zásobník
    return S.SP == N;
}

bool IsFullM(const Zasobnik& S){   //kontrola zda zásobník je prázdny
    //pokud stack pointer má hodnotu 0 tak vyhodi returnem true - prázdný zásobník
    return S.SP == M;
}

void naplnit(Zasobnik & lokomotiva){
        cout<<"Masina: "<<endl;
        for(int i = 1; i <= M; i++){
            //Vytvoøení vagonu: datový typ "Vagon" a promìnná "vozik"
            Vagon vozik;
            vozik.id=i;

            //vložení identifikace vagonu (i) s identifikací na kterou kolej patøí (gen) a následné pøipojení k lokomotivì
            Push(lokomotiva, vozik);

            //výpis ve formátu G#1[K#2] - kde G#1 je identifikace vygenerovaného prvního vagonu a [K#2] je identifikacé tøetí slepé koleje s oznaèením 2
            cout<<"G"<<i<<" ";
    }
}

void predanie(Zasobnik &odkud, Zasobnik &kam)
{
        Vagon tmp;
        tmp.id;
        tmp = Pop(odkud);
        Push(kam, tmp);

        cout << "O" <<tmp.id << " ";
        tmp.id++;
}


int main()
{

    //Vytvoření zásobníku se jménem lokomotiva
    Zasobnik lokomotiva;
    //vyčištění - vynulvání zásobníku
    Clear(lokomotiva);
    //náhodné naplnění zásobníku "lokomotiva"
    naplnit(lokomotiva);

    Zasobnik kolaj;

    Zoznam* hlava;
    hlava = NULL;

    cout<<endl<<endl<< "Prepajanie" << endl;
    int poradie=0;
     while(!IsEmpty(lokomotiva) )
    {
            while(poradie<1)
              {
        if (IsFull(kolaj))
            {
        Zoznam* temp = new Zoznam();
        temp->data=(kolaj);
        temp->dalsi = NULL;
        hlava = temp;
        Zoznam* temp1 = hlava;
        while (temp1->dalsi!= NULL)
            {
                temp1 = temp1->dalsi;

            }
        temp = new Zoznam();
        temp->data=(kolaj);
        temp->dalsi=NULL;
        temp1->dalsi=temp;
        poradie++;
        cout << "K" <<poradie <<" ";
}

    else
        {
            Clear(kolaj);
        }

        Vagon tmp;
        //skopirovanie vagonu z lokomotivy
            tmp = Look(lokomotiva);
        //pripojenie vagona z lokomotivy na kolaj
            predanie(lokomotiva, kolaj);
}

    }
    return 0;
}

Plus, keď zmažem  

while(poradie<1)

tak sa mi vytvorí 50 zásobníkov s 1 prvkom