Stack – C / C++ – Fórum – Programujte.com

Mojou úlohou je naprogramovať zásobník, ktorý pre uloženie položiek používa dynamické pole.
Nechápem tam len jednej veci a to funkcia pop. 

//top = posledny prvok
//pitems = smernik na zaciatok dynamickeho pola
bool Stack::pop_back(Item & item){
	if(top > 0){
		item = pitems[--top];
		return true;
	}
	return false;
}

prečo sa k položke item priraďuje položka predtým a vôbec prečo má metóda nejaké parametre.
Šak keď sa jedná o zásobník, tak pri funckii pop nepotrebujem mať žiadne parametre, kedže mi odstráni vždy posledný prvok. Jednoducho znížim top.

bool Stack::pop_back(){
	if(top > 0){
		top--;
		return true;
	}
	return false;
}

Niekedy je to pozadovane spravanie, aby pop nie len ze ten prvok zmazal, ale aby ta aj informoval o tom co za prvok zmazal, preto ten parameter. No a preco je tam --top, tak to je jednoduche, mas v zasobniku 3 prvky, top je teda 3 a ak zavolas pop, tak dekrementujes top na 2 a vratis prvok na pozicii 2, ktory je posledny v zasobniku, kedze sa indexuje od 0.

Shrnul bych to asi takto:

http://cs.wikipedia.org/wiki/Z%C3%A1sobn%C3%ADk_(datov%C3%A1_struktura)

#include <iostream>
 
using namespace std;
 
class Stack
{
private:
    int *p;
    int top,length;
 
public:
    Stack(int = 0);
    ~Stack();
 
    void push(int);
    int pop();
    void display();
};
 
Stack::Stack(int size)
{
    top=-1;
    length=size;
    if(size == 0)
        p = 0;
    else
        p=new int[length];
}
 
Stack::~Stack()
{
    if(p!=0)
        delete [] p;
}
 
void Stack::push(int elem)
{
    if(p == 0)                //If the stack size is zero, allow user to mention it at runtime
    {
        cout<<"Stack of zero size"<<endl;
        cout<<"Enter a size for stack : ";
        cin >> length;
        p=new int[length];
    }
    if(top==(length-1))     //If the top reaches to the maximum stack size
    {
        cout<<"\nCannot push "<<elem<<", Stack full"<<endl;
        return;
    }
    else
    {
        top++;
        p[top]=elem;
    }
}
int Stack::pop()
{
    if(p==0 || top==-1)
    {
        cout<<"Stack empty!";
        return -1;
    }
    int ret=p[top];
    top--;
    length--;
 
    return ret;
}
 
void Stack::display()
{
    for(int i = 0; i <= top; i++)
        cout<<p[i]<<" ";
    cout<<endl;
}
 
int main()
{
    Stack s1;             //We are creating a stack of size 'zero'
    s1.push(1);
    s1.display();
    s1.push(2);
    s1.push(3);
    s1.push(4);
    s1.push(5);
    s1.display();
    s1.pop();
    s1.display();
    s1.pop();
    s1.display();
    s1.pop();
    s1.display();
    s1.pop();
    s1.display();
}

#1 Robo
Ten tvoj zasobnik ma zopar vad. Konstruktori sa volaju pre cele pole aj ked je zasobnik prazdny. Dalsia nevyhoda je ze pri volani pop() sa nevola destructor pre Item. Item musi mat pretazeny operatot=. Ak je item primityvny typ ako int alebo jednoducha sruktura tak to nevadi ale pre zlozitejsie triedy je nepouzitelny.

Takto to mám spravené

#include <iostream>
#include "prd.h"

Stack::Stack(){
	pitems = new Item[MAX];
	size = 0;
	top = 0;
}

Stack::~Stack(){
	delete [] pitems;
}

Stack::Stack(const Stack & st){
	pitems = new Item[MAX];
	size = st.size;
	top = st.top;

	for(int i = 0; i < st.top; i++){
		pitems[i] = st.pitems[i];
	}
}
	
bool Stack::isempty(){
	return size == 0;
}

bool Stack::isfull(){
	return size == MAX;
}

bool Stack::push_back(const Item & item){
	if(top < MAX){
		pitems[top++] = item;
		size++;
		return true;
	}
	return false;
}

bool Stack::pop_back(){
	if(top > 0){
		top--;
		size--;
		return true;
	}
	return false;
}

Stack & Stack::operator=(const Stack & st){
	if(this == & st)
		return *this;
	delete [] pitems;
	pitems = new Item[MAX];
	size = st.size;
	top = st.top;

	for(int i = 0; i < st.top; i++){
		pitems[i] = st.pitems[i];
	}
	return *this;
}

std::ostream & operator<<(std::ostream & os, const Stack & st){
	for(int i = 0; i < st.top; i++){
		os << st.pitems[i] << std::endl;
	}
	return os;
}

Akurát ten pop som nechápal, prečo je to tak riešené
#4 vitamin
šak ja aj tak volám konštruktor, že mi vytvorí celé pole a deštruktor mi ho potom uvoľní