Hejsan!
Jag håller på att försöka programmera en stack som kan
hålla max 3 heltal. Min push funktion funkar bra och reagerar
fint på stackens storlek. Men då jag skall poppa ett heltal,
kan jag bara poppa det översta talet på stacken. Hur
skall jag skriva om min pop-funktion så att den poppar resten
av talen i stacken också.

Jag vet att jag måste göra någo med "top" variabeln för
att hålla koll på vilken som är högst på stacken.

här är källkoden för push och pop funktionerna.

void Stack::push(int tal){
int i;
for(i = 0; i < tal; i++)
{
mTab[i] = tal;
top = tal;
}
mTab[++mIndex] = tal;
mFullstack++;
cout << "top= " << top << endl;

}

int Stack::pop(){
int i;
for(i = 0; i < mIndex; i++)
{
mTab[i] = mIndex;
}
return (mTab[mIndex--]);
//mFullstack--;
}

tack;

<b>void Stack::push(int tal){</b>

Vad är <b>tal</b>? Är det talet som skall läggas på stacken? I så fall, varför har du <b>for(i = 0; i < tal; i++)</b>? Eller är det antalet tal som redan ligger på stacken? Vad är det då som läggs på stacken?

Förklara gärna alla variabler: mTab, mIndex, mFullstack, top.

JA: tal variabeln är talet som läggs på stacken.
Den där for loopen är jag inte heller riktigt säker om den behövs.
Jag är relativt ny till c++ språket, men kämpar hårt ändå.
Dessutom har jag problem med att returnera storleken av stacken
då jag har en full stack. Jag får programmet endast att visa 4 bytes för
storleken.




här är hela källkoden:

#include <iostream>
#include <string>
#include <stack>

const char ae=char(132);
const char ao=char(134);
#define STACK_MAX 3

using namespace std;

class Stack{
private:
int mIndex;//håller koll på hur många heltal stacken innehåller
int mFullstack; //variabel för koll på om stacken är full(inte säker om behövs)
int mTab[3]; // tabell som kan innehålla ett visst antal element.
int top; //variabel som kontrollerar vilket element som är högst i stacken
public:
Stack();
void init();
void push(int);
int pop();
int size();
int empty();
int full();
void free();
};

Stack::Stack(){
mIndex = 0;
mFullstack = 0;
mTab[3] = 0;
top = 0;
}



void Stack::init(){
mFullstack = 0;
mTab[3] = 0;
mIndex = -1;
top = 0;
cout << "Maximal stackstorlek: 3" << endl;
}

void Stack::push(int tal){
int i;
for(i = 0; i < tal; i++)
{
mTab[i] = tal;
top = mTab[i];
}
mTab[++mIndex] = tal;
cout << "tal= " << tal << endl;
cout << "top= " << top << endl;
}


int Stack::empty(){
if(mIndex == -1)
{
return true;
}
else
return false;
}
int Stack::full(){
if(mFullstack == STACK_MAX)
{
return true;
}
else
return false;
}

int Stack::pop(){
int i;

return (mTab[mIndex--]);
mFullstack--;

}


void Stack::free(){
for(; mIndex>= -1; mIndex--)
{
mTab[mIndex] = 0;
}
}

int Stack::size(){
return sizeof(mIndex);
}





int main()
{
int cont=1,tal; char val;
Stack a;

a.init();
while (cont) {
cout << "p-push, o-pop, s-storlek, a-avsluta ? "; cin >> val;
switch (val) {
case 'p':
if (a.full())
cout << "Stacken "<<ae<< "r full!" << endl;
else {
cout << "(push) Ge ett heltal : ";
cin >> tal;
a.push(tal);
}
break;
case 'o':
if (a.empty())
cout << "Stacken "<<ae<< "r tom!" << endl;
else {
cout << a.pop();
cout << " fr"<<ao<<"n stacken!" << endl;
}
break;
case 's':
cout << "Stackens nuvarande storlek : ";
cout << a.size() << endl;
break;
case 'q':
cont=0; break;
case 'a':
cout << "Hej hej!" << endl;
exit(0);
break;
default:
cout << "Felaktig tangent nedtryckt. " << endl;
}
}
a.free();
}

Hejsan...

Kom på hur man skulle göra funktionen pop()....

Här är en lösning....

#include <iostream>
#include <string>
#include <stack>

const char ae=char(132);
const char ao=char(134);
#define STACK_MAX 3


using namespace std;

class Stack{
private:
int mIndex;//håller koll på hur många heltal stacken innehåller
int mFullstack;
int top;
int *items;
int storlek;
public:
Stack();
~Stack();
void init();
void push(int);
int pop();
int size();
int empty();
int full();
void free();
};

Stack::Stack(){
mIndex = -1;
mFullstack = 0;
top = -1;
items = new int[STACK_MAX];
storlek = 0;
}

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


void Stack::init(){
mFullstack = 0;
mIndex = -1;
top = -1;
items = new int[STACK_MAX];
storlek = 0;
cout << "----------Stack----------"<<endl << endl;
cout << "Maximal stackstorlek: 3" << endl;
cout << "Stacken accepterar endast heltal" << endl << endl;
}


void Stack::push(int tal){

mIndex++;
mFullstack++;
items[++top] = tal;
storlek += sizeof(items[mIndex]);

}

int Stack::pop(){

mIndex--;
storlek -= sizeof(items[mIndex]);
mFullstack--;
return items[top--];
}


int Stack::empty(){
if(mIndex == -1)
{
return true;
}
else
return false;
}
int Stack::full(){
if(mFullstack == STACK_MAX)
{
return true;
}
else
return false;
}

void Stack::free(){
for(; mIndex>= -1; mIndex--)
{
items[mIndex] = 0;
}
}

int Stack::size(){
return storlek;
//return sizeof(items[mIndex]);
}


int main()
{

int cont=1,tal; char val;
Stack a;
a.init();
while (cont) {
cout << "p-push, o-pop, s-storlek, a-avsluta ? "; cin >> val;
switch (val) {
case 'p':
if (a.full())
cout << "Stacken "<<ae<< "r full!" << endl;
else {
cout << "(push) Ge ett heltal : ";
cin >> tal;
a.push(tal);
}
break;
case 'o':
if (a.empty())
cout << "Stacken "<<ae<< "r tom!" << endl;
else {
cout << a.pop();
cout << " fr"<<ao<<"n stacken!" << endl;
}
break;
case 's':
cout << "Stackens nuvarande storlek : ";
cout << a.size() << endl;
break;
case 'q':
cont=0; break;
case 'a':
cout << "Hej hej!" << endl;
exit(0);
break;
default:
cout << "Felaktig tangent nedtryckt. " << endl;
}
}
a.free();
}

Eftersom du skriver att du är ny på språket är det nog inte det här du vill höra, men ofta(st?) så använder man en länkad lista snarare än en vektor för att hantera det.

Men du har krånglat till det lite. Om du nödvändigtvis ska använda en "rå array" (vilket du inte bör) så kan du göra något i stil med följande. Jag har tagit bort saker som du inte bör ha med, och lagt till "top":

class Stack{
      public:
             Stack(int size=3);
             ~Stack();

             void push(int);
             int pop();
             int top();
             int size();
             bool empty();
             bool full();
      private:
             int _size
             int _currentindex;
             int * _items;
      };

Stack::Stack(int size): _size(size), _currentindex(-1){
      _items = new int[_size];
} 

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


void Stack::push(int tal){   
      if(full())
            return; //kasta exception eller något
      _items[++_currentindex]=tal;
}

int Stack::pop(){   
      if(empty())
            return; //kasta exception eller något
      return _items[_currentindex--];
} 

int Stack::top(){   
      if(empty())
            return; //kasta exception eller något
      return _items[_currentindex];
} 

int Stack::size(){   
      return _size;
} 

bool Stack::empty(){   
      return _currentindex==-1;
} 

bool Stack::full(){   
      return _currentindex==size;
} 

Varför över huvud taget skriva en egen stack? Använd stl:s stack istället. Se http://www.sgi.com/tech/stl/stack.html. Om du inte har tillgång till stl pga att du är på någon obskyr plattform så finns alltid SGI:s källkod att ladda ned på http://www.sgi.com/tech/stl/download.html som fungerar på de flesta miljöer.

Men om du gör det som en akademisk övning så förstår jag dig. Alltid bra att lära sig hur det fungerar under huven :-).

En kommentar till tidigare inlägg: jag tycker visst att det är bra att använda en array som grund istället för länkad lista eftersom om du lagrar små värden så blir det mycket overhead med framåt-och bakåtpekare i varje element (ex: stack<int> ger en int : 4 bytes samt 2 pekare : 2x4 = 8 bytes per element. Dvs en overhead på 66%.

Lagrar du 100.000 heltal så spelar detta roll.

Haken med en array är att den eventuellt måste omallokeras med jämna mellanrum efter hand arrayen växer (använd då stl::vector som sköter detta automatiskt), men om du har element med pekare måste du å andra sidan allokera ett element i taget vilket kan påverka prestanda och orsaka fragmentering.

/Andreas

<b>>Varför över huvud taget skriva en egen stack? Använd stl:s stack istället.</b>
Jo, naturligtvis, men jag förutsatte att:
<b>>Men om du gör det som en akademisk övning så förstår jag dig. </b>

<b>>En kommentar till tidigare inlägg: jag tycker visst att det är bra att använda en array som grund istället för länkad lista eftersom om du lagrar små värden så blir det mycket overhead med framåt-och bakåtpekare i varje element (ex: stack<int> ger en int : 4 bytes samt 2 pekare : 2x4 = 8 bytes per element. Dvs en overhead på 66%.</b>

Fast nu handlar det ju ofta i allmänhet om större datatyper än int:ar.

<b>>Haken med en array är att den eventuellt måste omallokeras med jämna mellanrum efter hand arrayen växer (använd då stl::vector som sköter detta automatiskt), men om du har element med pekare måste du å andra sidan allokera ett element i taget vilket kan påverka prestanda och orsaka fragmentering.</b>
Tja, fast min åsikt är ju snarare att om man gör en stack för att lära sig, så bör ju inte prestanda vara den största grejen, och inte heller exakt underliggande datastruktur. Så jag anser snarare att det är lämpligt att använda std::list eller std::vector istället. De viktigaste bitarna vad avser en stack är ju egentligen hur man löser FILO-delen. Och är man i stadiet att lära sig en stack så bör man ju redan ha koll på hur länkade listor funkar.