Operacje na stosie w klasie

0

Witam :)
Mam do zrobienia zadanie w którym w klasie tworze dwa stosy i mam na nich robić operacje dodawania odejmowania mnożenia i dzielenia...
Powstał kod który wygląda mniej więcej tak:
plik stos.h:

int *backup;
class stack
{
public:
        void push(int a);  // dodanie elementu do stosu
        int pop();    // usunięcie elementu ze stosu
        void clear();  // czyszczenie stosu
        int getStackSize(); //pokazuje rozmiar stosu
        stack();                    // wywolanie stosu  (kostruktor)
        stack(int size);          // wywolanie stosu  (kostruktor z zadanym rozmiarem stosu)
        stack(stack& s);        // konstruktor kopiowania
        ~stack();                       // destruktor
        stack& operator=(stack& s);          // operator kopiowania
        int update();            // funkcja powiększająca stos
        void show();            // wyświetlanie stosu
 
private:
        int size; // rozmiar stosu
        int top; // pozycja ostatniego elementu
        int* dane; // stos
};
 

i plik stos.cpp:

    #include <iostream>
    #include <windows.h>
    #include "stos.h"
     
    using namespace std;
     
    int main()
    {
        int liczba;
        int i,key,choise;
        stack stos, stos2; // deklaracja zmiennej danej klasy (poprzez tą zmienna odwołujemy sie do danej klasy)
        stack(); // rozpoczęcie stosu
        key=1;
        while(key!=0)
        {
              cout<<"Zmiany w widoku stosu sa realizowane z opoznieniem.";
              cout<<"Co chcesz zrobic?\n";
              cout<<"1-Push()\n";
              cout<<"2-Pop()\n";
              cout<<"3-Clear()\n";
              cout<<"4-Size\n";
              // wariany w menu które sa realizowane w switch ponizej
              cin>>choise;
              switch(choise)
              {
                            case 1:
                                int ilosc;
                                cout<<"Podaj ilosc liczb ktore chcesz kolejno dodac do stosu: ";
                                cin>>ilosc;
                                for(i=0;i<ilosc;i++)
                                {
                                    liczba=rand()%10;
                                    stos.push(liczba);
                                }
                                cout<<"Podaj ilosc liczb ktore chcesz kolejno dodac do stosu 2: ";
                                cin>>ilosc;
                                for(i=0;i<ilosc;i++)
                                {
                                    liczba=rand()%10;
                                    stos2.push(liczba);
                                }
                                break;
                       case 2:
                            cout<<"Podaj z ktorego stosu chcesz usunac liczbe:(1 czy 2): ";
                            cin>>liczba;
                            if(liczba==1)
                                         stos.pop();
                            else
                            stos2.pop();
                            break;
                       case 3:
                            cout<<"Podaj ktory stos ma byc usuniety (1 czy 2): ";
                            cin>>liczba;
                            if(liczba==1)
                                         stos.clear();
                            else
                            stos2.clear();
                            break;
                       case 4:
                            stos.getStackSize();
                            stos2.getStackSize();
                            break;
              }
     
     
              stos.show();
              stos2.show();
              cout<<endl;
              cout<<"Kontynuowac? 1-tak 0-nie: ";
              cin>>key;
              system("cls");
              stos.show();
              stos2.show();
        }
        stos.show();
        stos.~stack();
        stos2.show();
        stos2.~stack();
        cout<<"\n\n";
        return 0;
    }
     
     
    //**********************************************************************
    void stack::push(int a)
    {
     
         this->dane[top]=a; // dodawanie liczby a do stosu
         this->top++;
         if(top==size)
         update();
         cout<<"Dodano liczbe "<<a<<" do stosu.\n";
    }
    //**********************************************************************
    int stack::pop()
    {
        if (top>0) // usuwanie ostatniej liczby ze stosu jesli jest taka mozliwosc
        {
                   this->top--;
                   cout<<"Usunieto ostatnia liczbe ze stosu.\n";
        }
        else
        {
                   cout<<"Brak elementów do usuniecia.\n";
        }
        }
    //**********************************************************************
    void stack::clear()
    {
         this->top=0; //  czyszczenie stosu
         cout<<"Stos wyczyszczono.";
    }
    //**********************************************************************
    void stack::show() // Fukcja wypisująca stos oraz podaje ile liczb jest w stosie
    {
        int j=top;
        int t=16;
        cout<<"Na stosie znajduje sie "<<top<<" liczb.";
        cout<<"Te liczby to:";
     
     for(int i=0;i<j;i++)
        {
            cout<<dane[i];
            t++;
        }
     
    }
    //**********************************************************************
    stack::stack()
    {
            this->top=0; // rozpoczęcie stosu i przypisanie zmiennej top wartosci zero
            int* dane = new int[4];
            this->size=4;
    }
    //**********************************************************************
    stack::~stack()
    {
                   delete[] dane;
    }
    //**********************************************************************
    stack::stack(int Nsize)
    {
        this->top=0; // rozpoczęcie stosu i przypisanie zmiennej top wartosci zero
        dane = new int[Nsize];
        size = Nsize;
    }
    //**********************************************************************
    stack::stack(stack& s)
    {
        this-> dane = new int [s.size];
         
        for (int i=0;i<s.size; i++)
        this->dane[i] = s.dane[i];
         
        this->size = s.size;
        cout<<"Stos został sklonowany.\n";
    }
    //**********************************************************************
    stack& stack::operator=(stack& s)
    {
        delete[] dane;
        this->dane= new int[s.size];
        for (int i=0;i<s.size; i++)
        this->dane[i] = s.dane[i];
        this->size = s.size;
     }
    //**********************************************************************
    int stack::getStackSize()
    {
        cout<<"Stos ma rozmiar "<<size<<" wyrazów.";
    }
    //**********************************************************************
    int stack::update()
    {
        int i;
        backup= new int[size];
        for(i=0;i<size;i++)
        backup[i]=dane[i];
        delete[] dane;
        size+=4;
        this->dane= new int[size];
        for(i=0;i<size;i++)
            dane[i]=backup[i];
        delete[] backup;
        cout<<"Stos zostal powiekszony.";
    }
 

Wywala mi przy wpisywaniu liczb do drugiego stosu... a jeszcze nawet żadnych funkcji nie mam... co robię nie tak?!

0

Linia int* dane = new int[4]; w konstruktorze bezargumentowym tworzy nową zmienną lokalną o nazwie dane. Ta deklaracja przykrywa zmienną dane zadeklarowaną w klasie stack. Parę uwag: this-> jest w tym wypadku absolutnie niepotrzebny. Zmienna backup też jest zbędna, zrób update tylko z jednym kopiowaniem, nie z dwoma. Dodatkowo stack() nie rozpoczyna stosu, tylko tworzy (i od razu niszczy) tymczasową zmienną typu stack.

0

Dawaj this-> albo wszędzie, albo nigdzie, byle nie wymiennie bo to tylko pogarsza sprawę. Osobiście jest zwolennikiem jawnego pisania this wszędzie, wymaga napisania trochę więcej tekstu ale znacznie poprawia czytelność kodu.

1 użytkowników online, w tym zalogowanych: 0, gości: 1