Stos z tablicą dynammiczną

Dzień Dobry
Mam za zadanie stworzyć program, który będzie działał jak stos. T.j. musi mieć funkcję, która pozwoli wypełnić stos liczbami podanymi przez użytkownika, dodać nowy element oraz odczytać element z wierzchołka. Nie mogę sobie poradzić z tym zadaniem. Będę wdzięczna za pomoc.

#include <iostream>

using namespace std;

int rozmiar;
void dodaj(int* tablica)
{
    int element;
    for (int i = 0; i < rozmiar; i++) {
        cout << "podaj " << i + 1 << " element stosu: ";
        cin >> element;
        tablica[i] = element;
    }
}
void wyswietl(int* tablica)
{
    for (int i = 0; i < rozmiar; i++) {
        cout << tablica[i] << endl;
    }
}

void zapisz_na_wierzcholku(int* tablica)
{
    int wierzcholek;
    cout << "Jaka liczbe chcesz zapisac na wierzcholku stosu ?";
    cin >> wierzcholek;

    int indeks;
    int i = 0;
    rozmiar = rozmiar + 1;
    wierzcholek = tablica[0];
    while (i < rozmiar) {

        tablica[i] = tablica[i + 1];
        cout << tablica[i] << endl;
        i++;
    }
}

int main()
{

    cout << "podaj rozmiar tablica: ";
    cin >> rozmiar;
    int* tablica = new int[rozmiar];
    dodaj(tablica);
    wyswietl(tablica);
    zapisz_na_wierzcholku(tablica);

    delete[] tablica;
    return 0;
}


 

Po pierwsze możesz wykorzystać do tego listy i vectory zamiast statycznych tablic - wtedy to zadanie to właściwie 4 linijki :) jeśli jednak masz gdzieś napisane ze nie możesz z nich korzystać to polecam zdefiniowanie własnej struktury na próbę list. Struktura powinna wtedy przechowywać rozmiar aktualny rozmiar tablicy i wskaźnik na nią. Podczas dodawania i zdejmowania jednego elementu po prostu zwiększasz rozmiar tablicy o jeden

class MyStack
{
private:
    std::vector<int> stack;
public:
    void push(int element)
    {
        stack.push_back(element);
    }

    int pop()
    {
        if(stack.size() > 0)
        {
            return stack[stack.size()-1];
        }
        else
        { /*tutaj obsluga bledu*/ }
    }

    void show()
    {
        for (auto elemenet : stack)
        {
            cout << element << "\n";
        }
    }
}; 

wersja bardzo podstawowa (dla wykladowcy powinno wystarczyc). Jezeli chcesz program ulepszyc to

1. Zdefiniuj operatory (przypisania, porownania etc)
2. zamiast int niech bedzie to klasa szablonowa
3. zrob to tak jak dziala std::stack

Nie masz sama stosu na nowo robić. Tylko apkę.
Coś w stylu:

#include <iostream>
#include <vector>
#include <functional>
#include <unordered_map>

namespace app {
	using model = std::vector<int>;
	
	namespace controller {
		void push(app::model &model, model::value_type val) {
			model.emplace_back(val);
		}
		
		bool pop(app::model &model) {
			if(model.size()) {
				model.pop_back();
				return true;
			}
			return false;
		}
	}
	
	namespace view {
		void all(app::model const &model) {
			std::cout << "[ ";
			for(auto el: model) {
				std::cout << el << " ";
			}
			std::cout << "]" << std::endl;
		}
		
		void push(app::model &m) {
			model::value_type val;
			std::cin >> val;
			controller::push(m, val);
		}
		
		void pop(model &m) {
			if(!controller::pop(m)) {
				std::cout << "cannot pop from empty collection." << std::endl;
			}
		}
	}
}

namespace routes {
	using route = std::string;
	using handler = std::function<void()>;
	using router = std::unordered_map<route, handler>;
}

int main() {
	app::model model;
	
	routes::router const router = {
		{"all",  [&]{ app::view::all(model); }},
		{"push", [&]{ app::view::push(model); }},
		{"pop",  [&]{ app::view::pop(model); }}
	};
	
	routes::route route;
	while(std::cin >> route) {
		if(router.count(route)) {
			router.at(route)();
		}
		else {
			std::cout << "invalid route!" << std::endl;
		}
	}
	return 0;
}

input:

all
push 1
all
pop
all
push 1
push 2
push 3
gruszka
all
pop
pop
pop
pop

output:

[ ]
[ 1 ]
[ ]
invalid route!
[ 1 2 3 ]
cannot pop from empty collection.

http://ideone.com/FF37KW