C; Array; Stack; LIFO

[Da Mo (Gast)]

Ich habe folgendes Programm in C getippt um den Umgang mit einem Stack 
(LIFO -> Last In First Out) zu verstehen?

Mein Programm bittet um 10 Ganzzahlen (Array Feld 0 bis Feld 9) und gibt 
diese anschließend wieder aus (Array Feld 9 bis Feld 0).

Habe ich in meinem einfachen Demobeispiel LIFO korrekt umgesetzt?

Vielen Dank!

#define MAX 10

int array1[MAX]={};

int main()
{    
  //Push
  int i;
  for(i=0; i<MAX; i++)
  {
   int arr_var;
   
   printf("Bitte geben Sie eine Ganzzahl ein: ");
   scanf("%d", &array1[i]);
  }
  
  printf("\n");
  
  //Pop
  int l;
  
  for(l=(MAX-1); l>=0; l--)
  {
   printf("%d", array1[l]);
  }
  
  printf("\n\n"); 
  
  system("PAUSE");  
  return 0;
}

[Karl H. (kbuchegg)]

Do Ma schrieb:

> Mein Programm bittet um 10 Ganzzahlen (Array Feld 0 bis Feld 9) und gibt
> diese anschließend wieder aus (Array Feld 9 bis Feld 0).
>
> Habe ich in meinem einfachen Demobeispiel LIFO korrekt umgesetzt?

Na ja.
Es kommt zwar das richtige raus, aber einen Stack würde ich das noch 
nicht nennen wollen.

Bei einem richtigen Stack kannst du wahlfrei zwischen
  * auf den Stack pushen
  * vom Stack popen
wechseln, ohne dass da was durcheinander kommt.

Dein Programm ist zwar im Prinzip ein Stack, aber nur für den Sonderfall 
der Operationen
 * 10 Werte werden auf den Stack gepusht
 * danach werden die 10 Werte wieder vom Stack gepopt.

Diesen Sonderfall behandelt es richtig, von einem richtigen Stack ist 
das aber noch weit entfernt.
Ist ein bischen so, wie
Gleichungen lösen ist eigentlich ganz einfach
Gegeben die Gleichung
    2x = 10
dann lautet die Lösung: x = 5

Das Ergebnis ist zwar im Prinzip richtig, aber der Lösungsweg ist nicht 
allgemein genug angegeben, dass man diese Lösung als "er hat verstanden 
wie man Gleichungen löst" akzeptieren könnte.

[Klaus W. (mfgkw)]

rein formal schon: du liest das zuerst aus, was zuletzt reingeschrieben 
wurde.

Etwas näher an der Idee des LIFO wäre man dran, wenn man neben dem Feld 
auch den aktuellen Index halten würde (initalisiert mit 0) und den beim 
Abelegn erhöht und beim Entnehmen erniedrigt.
Typischerweise würde man das alles dann auch funktional etwas 
formalisieren und nicht händisch in der Schleife auf das Feld zugreifen 
zum Ablegen bzw. Entnehmen, sondern das über Funktionen realisieren 
(push/pop), die dann auch Fehler abfangen könnten wie Über- oder 
Unterlauf.

[Klaus W. (mfgkw)]

na, gut, war er wieder schneller :-)

Wenigstens widersprechen wir uns nicht...

[Da Mo (Gast)]

Wie darf ich die Auswahl ziwschen PUSH und POP verstehen? Ich dachte, 
LIFO ist nur erfüllt, wenn ich zuerst schreibe und dann in umgekehrter 
Richtung lese.

@Karl Heinz Buchegger

Wenn ich dich richtig verstanden habe, dann sollte es möglich sein, 
etwas aus dem Stapel "zu ziehen" oder "hinein zu schieben" oder?

[Daniel F. (df311)]

Do Ma schrieb:
> Wie darf ich die Auswahl ziwschen PUSH und POP verstehen

z.b. so (pseudocode):

stack.push(5);
stack.push(3);
stack.push(0);
echo stack.pop();
stack.push(4);
stack.pop();
echo stack.pop();

würde als ausgabe "0 3" ergeben

d.h. es ist komplett egal in welcher reihenfolge daten auf den stack 
gepusht oder vom stack gepopt werden. die implementierung sollte sich 
dann auch darum kümmern, dass bei einem pop ohne vorhergendem push ein 
fehler auftritt, der dann behandelt werden kann/muss...

[Da Mo (Gast)]

@Daniel F.

Ich kann mit "echo" nichts anfangen!?

[Klaus W. (mfgkw)]

Dann nimm printf!

[Da Mo (Gast)]

@Daniel F.

Warum würde dein Pseudocode die 5 nicht mehr ausgeben?

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Welche der obigen Anweisungen sollte denn bitte die 5 vom Stack lesen 
und ausgeben? Keine.

Die 5 bleibt einfach auf dem Stack liegen. Das kann je nach 
Ausführungsumgebung durchaus zu massiven Problemen führen. In dem 
Beispiel mit Pseudocode hat es natürlich keine Seiteneffekte, außer eben 
der Tatsache, dass zum Schluss die 5 auf dem Stack liegengeblieben ist.

Der Stack ist auch bildlich als Stapel zu verstehen. Wenn man morgens 
fünf Zettel auf den Stapel legt und im Laufe des Tages vier Zettel 
wieder entfernt, bleibt eben ein Zettel übrig. Macht man das jeden Tag, 
erhöht sich der Stapel um einen Zettel.

[Karl H. (kbuchegg)]

Do Ma schrieb:
> @Daniel F.
>
> Warum würde dein Pseudocode die 5 nicht mehr ausgeben?

Niemand hindert dich daran am Ende des Progamms einen Code einzufügen, 
welcher alle noch nicht gepopten Elemente vom Stack holt und den 
Benutzer vor dem Bildschirm darüber aufklärt, dass er nicht alles was er 
gepusht hat auch wieder gepopt hat.

[Karl H. (kbuchegg)]

Do Ma schrieb:
> Wie darf ich die Auswahl ziwschen PUSH und POP verstehen? Ich dachte,
> LIFO ist nur erfüllt, wenn ich zuerst schreibe und dann in umgekehrter
> Richtung lese.


Was heißt denn LIFO?

Last in - First Out


Das bedeutet nichts anderes als dass du beim Popen die einzelnen Zahlen 
in der umgekehrten Reihenfolge bekommst. Aber das sagt ja nichts darüber 
aus, dass die Operationen nicht abwechselnd erfolgen können.

Du hast einen Stapel Teller.
Buffetgäste welche sich Teller holen, kriegen immer die Teller zuerst 
die du zuletzt auf den Stapel gelegt hast. Und zwar in der umgekehrten 
Reihenfolge. Kein Mensch zwingt dich abzuwarten, bis keine Teller mehr 
da sind. Du kannst jederzeit neue Teller (einzeln) auf diesen Stapel 
legen. Dann kriegen eben die Gäste diese neuen aufgelegten Teller 
zuerst.

Nimm an auf deinem Teller stehen Zahlen. Du baust den Stapel mit 5 
Teller auf
    Tisch  |  1
    Tisch  |  1  2
    Tisch  |  1  2  3
    Tisch  |  1  2  3  8
    Tisch  |  1  2  3  8  15

Teller 15 ist als letztes aufgelegt worden.
Jetzt kommt ein Gast und holt sich einen Teller. Er kriegt Teller Nr. 
15, weil das der war, den du zum Schluss aufgelegt hast.
Dein Stapel Teller sieht daher jetzt so aus

    Tisch  |  1  2  3  8


Noch ein Gast holt sich einen Teller. Er kriegt die Nr 8 und der 
verbleibende Stapel sieht so aus

    Tisch  |  1  2  3

jetzt kommst du aus der Küche und legst noch 3 Teller auf den Stapel: 23 
5 und 9
erst die 23
    Tisch  |  1  2  3 23
dann die 5
    Tisch  |  1  2  3 23  5
und zum Schluss die 9
    Tisch  |  1  2  3 23  5  9

kommt jetzt ein Gast, und holt sich einen Teller, kriegt er die 9. 9 ist 
als letztes aufgelegt worden

    Tisch  |  1  2  3 23  5

der nächste kriegt 5

    Tisch  |  1  2  3 23

usw. usw.

[Da Mo (Gast)]

Mit folgendem Code, sollte LIFO erfüllt sein. Es sind noch einige 
kosmetische Änderungen notwendig aber mir geht es vorab nur um das 
Verständnis.

#include <stdio.h>
#include <stdlib.h>
#define MAX 5

int array1[MAX]={};
int counter1=0;

void push(int var1)
{
 array1[counter1]=var1;
 counter1++;
}

void pop()
{
 printf("\n%d\n", array1[counter1-1]);
 counter1--;
}

int main()
{ 
  int auswahl;
  int var2;
  int i;
  
  while(1)
  {
   printf("******************* Menue *******************\n\n");
   printf("Fuer die Funktion PUSH druecken Sie bitte <1>\n");
   printf("Fuer die Funktion POP  druecken Sie bitte <2>\n");
   printf("Fuer die Stack-Ansicht druecken Sie bitte <3>\n\n");
   printf("Auswahl: ");   //Eingabe in Klammern!?
   scanf("%d", &auswahl);
  
   if(auswahl==1)
   {
    if(counter1<MAX)
    {
     printf("\nWelchen Wert wollen Sie auf den Stapel legen?\n\n");
     printf("Wert: ");
     scanf("%d", &var2);
     push(var2); 
     printf("\n");
    }
    else if(counter1>=MAX)
    {
     printf("\nKein Platz mehr vorhanden!\n\n");
    }        
   }    
   else if(auswahl==2)
   {
    pop();
   }
   else if(auswahl==3)
   {
    printf("Stack-Ansicht:\n");    
    for(i=0; i<counter1; i++)
    {
     printf("%d", array1[i]);        
    }
    printf("\n");
   }
  } 

  system("PAUSE");  
  return 0;
}

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Das Prinzip ist jetzt zwar korrekt implementiert, aber die 
Strukturierung des ganzen Programms bereitet mir noch erhebliche 
Bauchschmerzen.

1. Die Funktion pop() sollte bei der obigen Implementierung eher 
pop_and_print() oder so heißen. Besser ist es jedoch, die Ausgabe im 
Hauptprogramm und nicht in pop() durchzuführen, da dadurch eine klare 
Aufteilung der Aufgaben realisiert wird.

2. Die Vermischung von Zugriffen auf array1[] und counter1 aus dem 
Hauptprogramm und aus Funktionen heraus ist ungünstig.

3. Für die Auswahl der durchzuführenden Aktion bieten sich switch/case 
eher an als ein Grab von if-Anweisungen.

[Klaus W. (mfgkw)]

ja, schon eher.

Wenn du jetzt auch noch die printf aus push und pop rausnimmst und zum 
Aufrufer verlegst und bei pop den gelesenen Wert zurückgibst, anstatt 
ihn in der Funktion gleich zu verwursten, sieht das schon aus, wie man 
sich einen LIFO so vorstellt.

Dann könnte man noch Fehlerbehandlung machen, sowie push, pop, das Feld 
und den Zähler in einen eigenen Quelltext verfrachten (static für die 
Variablen), damit der Aufrufer nicht direkt an das Feld herankommt ohne 
die Funktionen, und der Drop ist gelutscht.

[Klaus W. (mfgkw)]

Um dann doch noch was Neues zu bringen: wenn man in pop() die beiden 
Anweisungen tauscht, kann man sich das -1 schenken.

[Da Mo (Gast)]

Klaus Wachtler schrieb:
> sowie push, pop, das Feld
>
> und den Zähler in einen eigenen Quelltext verfrachten (static für die
>
> Variablen)

Was meinst du damit genau?

[Klaus W. (mfgkw)]

> Was meinst du damit genau?

Du schreibst eine eigene meinlifo.cpp:

#include "meinlifo.h"

static int array1[MAX]={};
static int counter1=0;

void push(int var1)
{
 array1[counter1]=var1;
 counter1++;
}

int pop()
{
 counter1--;
 return array1[counter1];
}

sowie eine meinelifo.h:

// etwas Kommentar...
#ifndef _MEINLIFO_H_
#define _MEINLIFO_H_

#define MAX 5

void push(int var1);
int pop();

#endif

In deinem Hauptprogramm nimmst du die entsprechenden Teiele raus und 
setzt dafür ein:

...
#include "meinlifo.h"
...

dazu.

Für MAX noch einen sinnvolleren Namen vielleicht...

[Da Mo (Gast)]

Umbau Nr. 1:

#include <stdio.h>
#include <stdlib.h>
#define FELDGROESSE 5

int array[FELDGROESSE]={};
int counter=0;

int value_push()
{
 int var; 
 if(counter<FELDGROESSE)
 {    
  printf("\nWelchen Wert wollen Sie auf den Stapel legen?\n\n");
  printf("Wert: ");
  scanf("%d", &var);
  printf("\n");
  return var;    
 }
 else if(counter>=FELDGROESSE)
 {
  printf("\nKein Platz mehr vorhanden!\n\n");
  return -1;
 }
}

void push(int var)
{ 
  if(var!=-1)
  {
   array[counter]=var;
   counter++;
  }
}

int pop()
{
 counter--;
 return array[counter];   
}

void print_elem(int fw_pop)
{
 printf("\n%d\n\n", fw_pop);
}

void print_stack()
{
 int i;
 printf("\nStack-Ansicht:\n\n");    
 for(i=0; i<counter; i++)
 {
  printf("%d ", array[i]);        
 }
 printf("\n");
}

int main()
{ 
 int auswahl;
 int end;
 int fw_pop;
 int fw_value_push;  
 while(end!=1)
 {
  printf("********************* Menue *********************\n\n");
  printf("Fuer die Funktion PUSH druecken Sie bitte     <1>\n");
  printf("Fuer die Funktion POP  druecken Sie bitte     <2>\n");
  printf("Fuer die Stack-Ansicht druecken Sie bitte     <3>\n");
  printf("Um das Programm zu beenden druecken Sie bitte <4>\n\n");
  printf("Auswahl: < >\b\b");
  scanf("%d", &auswahl); 
  switch(auswahl)
  {
   case 1: fw_value_push=value_push();
           push(fw_value_push);
           break;
   case 2: fw_pop=pop();
           print_elem(fw_pop);
           break;
   case 3: print_stack();
           break;
   case 4: end=1;
           break;
  }
 } 
 printf("\n********** Das Programm wurde beendet ***********\n\n"); 
 system("PAUSE");  
 return 0;
}

[Karl H. (kbuchegg)]

Do Ma schrieb:
> Umbau Nr. 1:

nicht gut.

Du musst die Dinge voneinander trennen!
Einen Stack zu haben ist eine Sache.
Werte vom Benutzer eingeben zu lassen ist eine andere Sache.

Die beiden haben nichts miteinander zu tun. Also solltest du sie auch 
nicht miteinander vermischen. Die Push bzw. Pop Funktionen übernehmen 
einen Wert bzw. liefern einen Wert. Das ist ihre Aufgabe. Wo dieser Wert 
her kommt, geht sie nichts an.

> void push(int var)
> {
>   if(var!=-1)
>   {
>    array[counter]=var;
>    counter++;
>   }
> }

hier muss die Überprüfung rein!

void push( int var )
{
  if( counter < FELDGROESSE )
  {
    array[counter] = var; 
    counter++;
  }
}

und beim pop genauso. Wenn deine I/O Funktionen zusätzlich noch prüfen 
ob Platz im Stack ist, dann ist das löblich. Aber in erster Linie muss 
der Stack auf sich selber aufpassen und Fehlbedienung verhindern. Es ist 
ja schliesslich nicht in Stein gemeisselt, dass der Stack nur von einem 
Benutzer gefüllt wird. Der Stack kann, darf und will gar nicht wissen, 
wo die Werte herkommen. Aber: Er muss die Nebenbedingung - Stack voll - 
berücksichtigen.

...
 if(counter<FELDGROESSE)
 {    
   ...
 }
 else if(counter>=FELDGROESSE)
 {
   ...
 }

das ist doppelt gemoppelt. Der else Zweig wird sowieso immer nur dann 
ausgefühtr, wenn die Bedingung im if nicht zutrifft. Wenn counter aber 
nicht kleiner als FELDGROESSE ist, dann kann counter nur noch größer 
oder gleich sein. Eine andere Möglichkeit gibt es nicht! Schreibst du 
die Bedingung trotzdem noch einmal hin, dann machst du dir erstens mehr 
Arbeit als notwendig und zweitens läufst du Gefahr, dass du dir dabei 
einen Fehler, und sei es nur ein banaler Tippfehler, einhandelst.


Und lass dir ein paar vernünftige Begriffe für deine Variablen 
einfallen! array, counter, FELDGROESSE, das kann alles und nichts sein.
Der geneigte Leser hat es hier mit einem Stack zu tun! Erinnere ihn bei 
jeder Zeile daran.
Das Array mit den Werten, welches den Stack bildet, kann man zb 
wunderbar "stack" nennen. Der counter ist allgemein als der 
"StackPointer" bekannt und die Arraygröße ist der alles entscheidende 
Punkt für die "STACK_SIZE"

#define STACK_SIZE   5
int Stack[STACK_SIZE];
int StackPointer;


void push( int Value )
{
  if( StackPointer < STACK_SIZE)
  {
    Stack[StackPointer] = Value; 
    StackPointer++;
  }
}

Ob und wie man im push auf die Fehlersituation reagiert, ist 
Ansichtssache. In Produktionscode würde das so sicher nicht gehen. Die 
Fehlersituation muss gemeldet werden. Wie das genau passiert, hängt dann 
auch von den Codingrichtlinien der einzelnen Firmen ab. Aber ein erster 
Ansatz wäre mal ein Returnwert, den der Aufrufer abfragen kann.

#define STACK_SIZE   5
int Stack[STACK_SIZE];
int StackPointer;

int push( int Value )
{
  if( StackPointer >= STACK_SIZE )
    return FALSE;

  Stack[StackPointer] = Value; 
  StackPointer++;

  return TRUE;
}

[Da Mo (Gast)]

Warum verwendet man die Bezeichnung stackpointer für einen counter?

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

In dieser konkreten Implementierung, nämmlich dass die Kennzeichnung des 
aktuellen Stapelelements durch den Index mit einer Schrittweite von eins 
erfolgt, mag der Unterschied nicht deutlich werden.

Bei vielen anderen Arten, einen Stack zu implementieren, wird jedoch ein 
Zeiger direkt auf den adressierten Speicher verwendet. Dann hängt die 
Schrittweite von der Größe der auf dem Stack abzulegenden Daten ab; 
diese muss nicht einmal einheitlich sein. Folglich ist dann ggf. sogar 
die Schrittweite variabel.

Be einigen Prozessoren gibt es auch keine Äquivalenz zwischen den 
möglichen Zählerdatentypen (z.B. Integer bzw. int) und Pointertypen, 
z.B. den x86 in segementierter Betriebsart.

Stackpointer werden nicht nur auf Hochsprachenebene verwendet, sondern 
bei sehr vielen Prozessoren auch auf Low-Level-Ebene, d.h. 
Unterprogrammaufrufe bewirken ein automatisches Speichern des aktuellen 
Programmzeigers (bzw. der Speicheradresse der nächsten folgenden 
Anweisung) auf dem Stack. Aus diesem Bereich kommt auch die 
ursprüngliche Definition des Begriffs Stackpointer. Bei Prozessoren, 
deren Stackpointer gleichzeitig als Register adressierbar ist, heißt er 
häufig SP. Einige Prozessoren (z.B. ARM) haben sogar mehrere 
Stackpointer für unterschiedliche Betriebsarten.

Interessanterweise heißt der Programmzeiger meist "Program Counter" und 
nicht "Program Pointer". Insofern gibt es schon eine gewisse 
Vermischung der beiden Begriffe "Zähler" und "Zeiger".

[Da Mo (Gast)]

Umbau Nr. 2:

Welche if-Bedingung in der Funktion print_elem() ist notwendig, um eine 
Ausgabe bei der Auswahl der Funktion pop() bei leerem Stack zu 
verhindern (bei leerem Stack ist der stackpointer 0)? Die Bedingung 
stackpointer >= 0 liefert Pseudowerte bei leerem Stack.

Die anderen Bereiche im Programm sollten jetzt korrekt sein!?

#include <stdio.h>
#include <stdlib.h>
#define STACK_SIZE 5

int stack[STACK_SIZE]={};
int stackpointer=0;

int value_push()
{
 int var;    
 printf("\nWelchen Wert wollen Sie auf den Stapel legen?\n\n");
 printf("Wert: ");
 scanf("%d", &var);
 printf("\n");
 return var;    
}

void push(int var)
{ 
  if(stackpointer < STACK_SIZE)
  {
   stack[stackpointer]=var;
   stackpointer++;
  }
}

int pop()
{
 if(stackpointer > 0)
 {
  stackpointer--;
  return stack[stackpointer];   
 }
}

void print_elem(int var)
{
 if() //???
 {
  printf("%d\n", var);
 }
}

void print_stack()
{
 int i;
 printf("\nStack-Ansicht:\n\n");    
 for(i=0; i<stackpointer; i++)
 {
  printf("%d ", stack[i]);        
 }
 printf("\n");
}

int main()
{ 
 int auswahl;
 int end;
 int fw_pop;
 int fw_value_push;  
 while(end!=1)
 {
  printf("********************* Menue *********************\n\n");
  printf("Fuer die Funktion PUSH druecken Sie bitte     <1>\n");
  printf("Fuer die Funktion POP  druecken Sie bitte     <2>\n");
  printf("Fuer die Stack-Ansicht druecken Sie bitte     <3>\n");
  printf("Um das Programm zu beenden druecken Sie bitte <4>\n\n");
  printf("Auswahl: < >\b\b");
  scanf("%d", &auswahl); 
  switch(auswahl)
  {
   case 1: fw_value_push=value_push();
           push(fw_value_push);
           break;
   case 2: fw_pop=pop();
           print_elem(fw_pop);
           break;
   case 3: print_stack();
           break;
   case 4: end=1;
           break;
  }
 } 
 printf("\n********** Das Programm wurde beendet ***********\n\n"); 
 system("PAUSE");  
 return 0;
}

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Nein, Du hast immer noch nicht Karl Heinz Bucheggers Ratschläge zur 
Trennung der Funktionalitäten korrekt umgesetzt.

[Da Mo (Gast)]

Die Funktionen push() und pop(), haben doch jetzt nur mehr die Aufgaben 
schreiben und lesen.

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

- push() und pop() liefern keinen Status zurück, anhand dessen man sehen 
kann, ob die Stackoperation funktioniert hat.

- push_value() bewirkt die Eingabe einer Zahl und hat nichts mit einer 
"push"-Operation zu tun.

- print_stack() vermischt Zugriffe auf den Stack und Benutzerausgaben.

- print_elem() gibt eine beliebige Zahl aus, deren Herkunft nicht 
unbedingt ein Stackelement sein muss. Somit ist der Name 
missverständlich.

[Karl H. (kbuchegg)]

int main()
{ 
 int auswahl;
 int end;
 int fw_pop;
 int fw_value_push;  
 while(end!=1)
 {
  printf("********************* Menue *********************\n\n");
  printf("Fuer die Funktion PUSH druecken Sie bitte     <1>\n");
  printf("Fuer die Funktion POP  druecken Sie bitte     <2>\n");
  printf("Fuer die Stack-Ansicht druecken Sie bitte     <3>\n");
  printf("Um das Programm zu beenden druecken Sie bitte <4>\n\n");
  printf("Auswahl: < >\b\b");
  scanf("%d", &auswahl); 
  switch(auswahl)
  {
   case 1: fw_value_push=value_push();
           push(fw_value_push);
           break;
   case 2: fw_pop=pop();
           print_elem(fw_pop);
           break;
   case 3: print_stack();
           break;
   case 4: end=1;
           break;
  }
 } 
 printf("\n********** Das Programm wurde beendet ***********\n\n"); 
 system("PAUSE");  
 return 0;
}

Man kann es mit der Zerlegung in Teilfunktionen auch übertreiben. 
Bringen dir hier die Funktionen value_push() bzw. print_elem() 
irgendwelche Vorteile?

Ich würde mal sagen: nein.
Ausser, dass du das Wissen über die Bedienung deines Programm möglichst 
weit quer über das Programm verstreust, bringen sie dir nichts.

Warum nicht ganz banal

int main()
{ 
 int auswahl = 0;
 int value;

 while(auswahl != 4)
 {
  printf("********************* Menue *********************\n\n");
  printf("Fuer die Funktion PUSH druecken Sie bitte     <1>\n");
  printf("Fuer die Funktion POP  druecken Sie bitte     <2>\n");
  printf("Fuer die Stack-Ansicht druecken Sie bitte     <3>\n");
  printf("Um das Programm zu beenden druecken Sie bitte <4>\n\n");
  printf("Auswahl: < >\b\b");
  scanf("%d", &auswahl); 

  switch(auswahl)
  {
   case 1: 
     printf("Wert: ");
     scanf("%d", &value);
     push( value );
     break;

   case 2:
     value = pop();
     printf("%d\n", value);
     break;

   case 3:
     print_stack();
     break;
  }
 }
 
 printf("\n********** Das Programm wurde beendet ***********\n\n"); 
 system("PAUSE");  
 return 0;
}

So. Und wenn du jetzt noch zu deinem Benutzer nett bist, dann machst du 
dir noch 2 Funktionen:
int isStackFull()
int isStackEmpty()

und abhängig von diesen beiden Funktionen bietest du nämlich deinem 
Benutzer dann die momentan nicht möglichen Menüpunkte gar nicht mehr an. 
Welchen Sinn soll es denn haben, wenn der Benutzer einen Menüpunkt 
auswählen kann, nur damit du ihm nachher sagst, dass die Operation gar 
nicht mehr geht. Das ist ein bischen so wie ein BUtton auf den man 
draufdrückt und dann taucht ein Text auf "Drücken sie hier nicht drauf"

int main()
{ 
 int auswahl = 0;
 int value;

 while(auswahl != 4)
 {
  printf("********************* Menue *********************\n\n");
  if( !isStackFull() )
    printf("Fuer die Funktion PUSH druecken Sie bitte     <1>\n");
  if( !isStackEmpty() )
    printf("Fuer die Funktion POP  druecken Sie bitte     <2>\n");
  printf("Fuer die Stack-Ansicht druecken Sie bitte     <3>\n");
  printf("Um das Programm zu beenden druecken Sie bitte <4>\n\n");
  printf("Auswahl: < >\b\b");
  scanf("%d", &auswahl); 

  switch(auswahl)
  {
   case 1:
     if( !isStackFull() )
     { 
       printf("Wert: ");
       scanf("%d", &value);
       push( value );
     }
     break;

   case 2:
     if( !isStackEmpty() )
     {
       value = pop();
       printf("%d\n", value);
     }
     break;

   case 3:
     print_stack();
     break;
  }
 }
 
 printf("\n********** Das Programm wurde beendet ***********\n\n"); 
 system("PAUSE");  
 return 0;
}

Und sei mit deinen Texten etwas weniger geschwätzig. Texte sollen 
ausreichend lang, aber auch nicht zu lang sein. Kein Mensch liest halbe 
Romane. Benutzer tendieren dazu, lange Texte nicht mehr wahrzunehmen 
sondern aus Gewohnheit irgendwo draufzudrücken.

Wenn ein Programm hochfährt und es meldet sich mit

Willkommen zum Stacktestprogramm Version 2.48,
geschrieben im Frühjahr 2012 vom Superprogrammierer xyz
als Vorbereitung zur Diplomarbeit seines Bruders.
Ich danke meinen Eltern für den Support, meinen Großeltern
fuer den neuen Computer und nicht zuletzt meiner Tante, die
das Mittagessen gemacht hat!
(C) 2012  [e-mail]

dann weiß jeder Programmierer, dass es sich um ein Anfängerprogramm 
handelt. Denn genau solche Begrüssungsnachrichten sind ein Markezeichen 
dafür. Erst kommt eine halbe Seite Begrüßung und dann hat der 
Programmierer nicht mehr weiter gewusst. Diese Begrüßungsmasken bei 
gekauften Programmen haben einen anderen Zweck. Sie sollen den Benutzer 
ein bischen beschäftigen, bis das Programm 25 DLLs und 68 Datendateien 
nachgeladen hat. Kommerzielle Programme haben einen etwas größeren 
Umfang und brauchen ein wenig Zeit um zu laden. Und damit der Benutzer 
Feedback hat, dass da tatsächlich etwas passiert, macht man so einen 
Splashscreen rein.

[Da Mo (Gast)]

Ich versuche mit nur einer Funktion die Menüpunkte und Funktionen push() 
und pop() ein- und auszublenden.

Wie es aussieht, denke ich falsch um die richtige else if-Bedingung zu 
finden.

stack_state()
{
 if(stackpointer < STACK_SIZE)
 {
  return 0;
 }
 else if(stackpointer  ) //Welche Bedingung ist dafuer notwendig?
 {              
  return 1;
 }              
}

[Da Mo (Gast)]

Umbau Nr. 3:

!!!Mein letzter Eintrag ist hinfällig (kann ihn leider nicht löschen)!!!

#include <stdio.h>
#include <stdlib.h>
#define STACK_SIZE 10

int stack[STACK_SIZE] = {};
int stackpointer = 0;

void push(int var)
{ 
 stack[stackpointer]=var;
 stackpointer++;
}

int pop()
{
 stackpointer--;
 return stack[stackpointer];   
}

stack_emty()
{
 if(stackpointer < STACK_SIZE)
 {
  return 0;
 }
 else if(stackpointer >= STACK_SIZE)
 {
 return 1;
 }            
}

stack_full()
{
 if(stackpointer > 0)
 {
  return 0;   
 }
 else
 {
  return 1;    
 }
}

void print_stack()
{
 int i;
 printf("\nStack-Ansicht:\n\n");    
 for(i = 0; i < stackpointer; i++)
 {
  printf("%d ", stack[i]);        
 }
 printf("\n");
}

int main()
{ 
 int auswahl = 0;
 int value;
   
 while(auswahl != 4)
 {
  printf("********************* Menue *********************\n\n");
  if(stack_emty() != 1)
  {
   printf("Fuer die Funktion PUSH druecken Sie bitte     <1>\n");
  }
  if(stack_full() != 1)
  {
   printf("Fuer die Funktion POP  druecken Sie bitte     <2>\n");
  }
  printf("Fuer die Stack-Ansicht druecken Sie bitte     <3>\n");
  printf("Um das Programm zu beenden druecken Sie bitte <4>\n\n");
  printf("Auswahl: < >\b\b");
  scanf("%d", &auswahl);
   
  switch(auswahl)
  {
   case 1: if(stack_emty() != 1)
           {
            printf("Wert: ");
            scanf("%d", &value);
            push(value);
           }
           break;
   case 2: if(stack_full() != 1)
           {
            value=pop();
            printf("%d\n", value);
           }
           break;
   case 3: print_stack();
           break;
  }
 }
  
 printf("\n********** Das Programm wurde beendet ***********\n\n");
  
 system("PAUSE");  
 return 0;
}

[Klaus W. (mfgkw)]

Über "halbvoll" und "halbleer" kann man philosophieren, aber über "voll" 
und "leer" habe ich andere Ansichten als du :-)

[Noname (Gast)]

>Das ist ein bischen so wie ein BUtton auf den man
>draufdrückt und dann taucht ein Text auf "Drücken sie hier nicht drauf"
Lach. Das taucht tatsächlich immer wieder mal als Gag auf.

stack_emty()
{
 if(stackpointer < STACK_SIZE)
 {
  return 0;
 }
 else if(stackpointer >= STACK_SIZE)
 {
 return 1;
 }            
}

Ein Stack ist nicht dann leer, wenn weniger Elemente darin sind als er 
fassen kann, sondern dann wenn mindestens ein Element darin ist. Das ist 
ein Unterschied. Kannst Du erklären welcher? Denk dran: EmPty wird 
gebraucht um zu entscheiden ob man was herunterholen kann.

stack_full()
{
 if(stackpointer > 0)
 {
  return 0;   
 }
 else
 {
  return 1;    
 }
}

Ebenso ist ein Stack nicht dann voll wenn er mehr als ein Element enhält 
sondern wenn er genauso viele Elemente enthält, wie er fassen kann.
Denke daran: "Full" wird gebraucht um zu entscheiden ob man noch was 
drauf-stapeln darf.

[Noname (Gast)]

Uups.

>Ein Stack ist nicht dann leer, wenn weniger Elemente darin sind als er
fassen kann, sondern dann wenn mindestens ein Element darin ist.

muss natürlich heissen:

Ein Stack ist nicht dann leer, wenn weniger Elemente darin sind als er
fassen kann, sondern dann wenn kein Element darin ist.

[Noname (Gast)]

Noch ein Beitrag dazu:

Von einem halbvollen Glas sagst Du, es sei voll.
Von einem halbleeren Glas sagst Du, es sei leer.

Das gibt Widersprüche! :-)

[Da Mo (Gast)]

Dann werde ich die Funktionen einfach stack_state1() und stack_state2() 
nennen. Somit ist die Gläserfrage beseitigt. :-)

#include <stdio.h>
#include <stdlib.h>
#define STACK_SIZE 10

int stack[STACK_SIZE] = {};
int stackpointer = 0;

void push(int var)
{ 
 stack[stackpointer]=var;
 stackpointer++;
}

int pop()
{
 stackpointer--;
 return stack[stackpointer];   
}

stack_state1()
{
 if(stackpointer < STACK_SIZE)
 {
  return 0;
 }
 else if(stackpointer >= STACK_SIZE)
 {
 return 1;
 }            
}

stack_state2()
{
 if(stackpointer > 0)
 {
  return 0;   
 }
 else
 {
  return 1;    
 }
}

void print_stack()
{
 int i;
 printf("\nStack-Ansicht:\n\n");    
 for(i = 0; i < stackpointer; i++)
 {
  printf("%d ", stack[i]);        
 }
 printf("\n");
}

int main()
{ 
 int auswahl = 0;
 int value;
   
 while(auswahl != 4)
 {
  printf("********************* Menue *********************\n\n");
  if(stack_state1() != 1)
  {
   printf("Fuer die Funktion PUSH druecken Sie bitte     <1>\n");
  }
  if(stack_state2() != 1)
  {
   printf("Fuer die Funktion POP  druecken Sie bitte     <2>\n");
  }
  printf("Fuer die Stack-Ansicht druecken Sie bitte     <3>\n");
  printf("Um das Programm zu beenden druecken Sie bitte <4>\n\n");
  printf("Auswahl: < >\b\b");
  scanf("%d", &auswahl);
   
  switch(auswahl)
  {
   case 1: if(stack_state1() != 1)
           {
            printf("Wert: ");
            scanf("%d", &value);
            push(value);
           }
           break;
   case 2: if(stack_state2() != 1)
           {
            value=pop();
            printf("%d\n", value);
           }
           break;
   case 3: print_stack();
           break;
  }
 }
  
 printf("\n********** Das Programm wurde beendet ***********\n\n");
  
 system("PAUSE");  
 return 0;
}

[Noname (Gast)]

>Dann werde ich die Funktionen einfach stack_state1() und stack_state2()
>nennen. Somit ist die Gläserfrage beseitigt. :-)

So geht das leider nicht. Ich fürchte ich habe Dich mit meiner 
humorvollen Ausdrucksweise dazu verleitet anzunehmen, das kein 
sachlicher Grund für eine kritische Betrachtung vorliegt. Das aber ist 
durchaus nicht der Fall.

Widersprüche in Software sind immer und absolut zu vermeiden!

Es geht nicht darum wie die Funktionen heissen, sondern was sie tun. Das 
sind zwei völlig verschiedene Dinge. Idealerweise passt der 
Funktionsname zu dem was sie tut. Aber das was die Funktione tut muss 
auch zu dem passen wie sie verwendet werden.

Du brauchst keine Funktion, die Dir ihrem Namen und ihrer Verwendung 
nach sagen soll, ob der Stack voll ist, die aber im Gegensatz dazu prüft 
ob Elemente im Stack sind und nicht ob der Stack tatsächlich voll ist.

Genauso brauchst Du keine Funktion, die Dir ihrem Namen und ihrer 
Verwendung nach sagen soll ob der Stack leer ist, die aber im Gegensatz 
dazu prüft, ob weniger Elemente darin sind als sie fassen kann.

Das habe ich aber schon geschrieben und das sollte Dir auch die Logik 
sagen.

stack_empty()
{
 if(stackpointer == 0)  // nur wenn kein Element auf dem Stack ist, dann ist er auch tatsächlich "leer" resp. "empty"
 {
  return 0;
 }
 else {
 return 1;
 }            
}

stack_full()
{
 if(stackpointer == SIZE) // nur wenn alle Elemente belegt sind, ist der Stack auch tatsächlich "voll" resp. "full".
 {
  return 0;   
 }
 else
 {
  return 1;    
 }
}

Im übrigen, weichst Du von der üblichen Deutung von 0 als Falsch und 1 
als Wahr ab. Da das aber Konvention ist, mag es so hingehen.

[Noname (Gast)]

Im übrigen ist der Name "stack_state1" anstatt "stack_full" ohnehin die 
schlechtere Wahl. Es ist ja nicht mehr erkennbar, auf welchen Zustand 
geprüft wird.

[Noname (Gast)]

Wenn Du Dir Deine Implementierungen anschaust und was sie zurückliefern, 
dann wird Dir vielleicht klarer was ich meine.


Stackbelegung 0 1 2 .... 20 21 STACKGRÖSSE
Stack_Full    F W W .... W  W  W
Stack_Empty   W W W .... W  W  F

Wobei Wahr = W = 0
und   Falsch = F = 1
gelten soll.

Eigentlich aber sollte das so aussehen.

Stackbelegung 0 1 2 .... 20 21 STACKGRÖSSE
Stack_Full    F F F .... F  F  W
Stack_Empty   W F F .... F  F  F


Nimm einmal an, Du erhieltest die Aufgabe den Stack in einer Datei zu 
sichern, falls er Daten entält.

Deine Stack-Empty Funktion kannst Du nicht verwenden, da sie solange 
Wahr liefert wie der Stack nicht voll ist.

Hingegen kannst Du meine Stack-Empty Funktion verwenden, das sie wahr 
liefert, sobald mindestens ein Element enthalten ist.

Das gleiche macht zwar Deine Stack_Full Funktion (nur negiert) aber 
stelle Dir mal Code vor der lautet:

if (Stack_Full () == Wahr)
   Sichere_Stack_In_Datei ();

Jeder der das liest, wird annehmen, das die Daten nur dann gesichert 
werden wenn der Stack voll ist. Aber Deine Aufgabe war ja den Stack auch 
zu sichern, wenn er zwar Elemente enthält aber weniger als hineinpassen.

Auch so funktioniert das zwar, aber man muss dazu die Funktion selbst 
erstmal studieren. Erstmal liest sich das wie ein Widerspruch!
Das ist keine gute Praxis. Es führt zu Verwirrung.

Klar, was ich meine?

[Noname (Gast)]

Tippfehler:

Es muss heissen:

Hingegen kannst Du meine Stack-Empty Funktion verwenden, das sie falsch
liefert, sobald mindestens ein Element enthalten ist.

[Noname (Gast)]

Lies nochmal den Programmtext mit mir, bitte:

   case 1: if(stack_emty() != 1)
           {
            printf("Wert: ");
            scanf("%d", &value);
            push(value);
           }
           break;
   case 2: if(stack_full() != 1)
           {
            value=pop();
            printf("%d\n", value);
           }

Da steht:

1. Wenn der Stack leer ist, kannst Du Daten hinein-pushen. Häh?
Darauf Du: Naja. Die Funktion liefert auch wahr, wenn der Stack nicht 
leer ist. Darauf ich: Und wenn er voll ist? Du: Dann liefert sie Falsch. 
Ich: Aha. Warum dann nicht:

if (stack_full () == 0)

schreiben? Das ist viel klarer (Abgesehen von der 0 = Wahr 
Verwechselung)

2. Wenn der Stack voll ist, kannst Du Daten heraus-poppen. Häh?
Darauf Du: Naja. Die Funktion liefert auch wahr wenn der Stack nicht 
voll ist. Ich: Und wenn er leer ist? Du: Dann liefert sie Falsch. Ich:
Aha. Warum dann nicht:

if (stack_empty () == 1)

schreiben? Das ist viel klarer.

Naja. Hoffe das ist von Nutzen. Wenn nicht ignoriere es.

:-)

[Noname (Gast)]

Ups. Noch ein Tippfehler. Sorry.

Ich: Aha. Warum dann nicht:

if (stack_full () == 1)

schreiben? Das ist viel klarer (Abgesehen von der 0 = Wahr
Verwechselung)

[Da Mo (Gast)]

Jetzt müsste es passen!?

#include <stdio.h>
#include <stdlib.h>
#define STACK_SIZE 5

int stack[STACK_SIZE] = {};
int stackpointer = 0;

void push(int var)
{ 
 stack[stackpointer]=var;
 stackpointer++;
}

int pop()
{
 stackpointer--;
 return stack[stackpointer];   
}

stack_full()
{
 if(stackpointer == STACK_SIZE)
 {
 return 1;
 }  
 return 0;          
}

stack_emty()
{
 if(stackpointer == 0)
 {
  return 1;   
 }
 else
 {
  return 0;    
 }
}

void print_stack()
{
 int i;
 printf("\nStack-Ansicht:\n\n");    
 for(i = 0; i < stackpointer; i++)
 {
  printf("%d ", stack[i]);        
 }
 printf("\n");
}

int main()
{ 
 int auswahl = 0;
 int value;
   
 while(auswahl != 4)
 {
  printf("********************* Menue *********************\n\n");
  if(stack_full() == 0)
  {
   printf("Fuer die Funktion PUSH druecken Sie bitte     <1>\n");
  }
  if(stack_emty() == 0)
  {
   printf("Fuer die Funktion POP  druecken Sie bitte     <2>\n");
  }
  printf("Fuer die Stack-Ansicht druecken Sie bitte     <3>\n");
  printf("Um das Programm zu beenden druecken Sie bitte <4>\n\n");
  printf("Auswahl: < >\b\b");
  scanf("%d", &auswahl);
   
  switch(auswahl)
  {
   case 1: if(stack_full() == 0)
           {
            printf("Wert: ");
            scanf("%d", &value);
            push(value);
           }
           break;
   case 2: if(stack_emty() == 0)
           {
            value=pop();
            printf("%d\n", value);
           }
           break;
   case 3: print_stack();
           break;
  }
 }
  
 printf("\n********** Das Programm wurde beendet ***********\n\n");
  
 system("PAUSE");  
 return 0;
}

[Noname (Gast)]

Besser. Und wenn Du Dir jetzt noch von einem freundlichen Nachbarn ein 
"p" ausleihst und "Empty" schreibst sind auch die 
Rechtschreibfetischisten (wie ich) befriedigt. :-)

[Da Mo (Gast)]

Vielen DANK für eure super Hilfe!!!

@Noname

Mein Nachbar war so nett...

#include <stdio.h>
#include <stdlib.h>
#define STACK_SIZE 5

int stack[STACK_SIZE] = {};
int stackpointer = 0;

void push(int var)
{ 
 stack[stackpointer]=var;
 stackpointer++;
}

int pop()
{
 stackpointer--;
 return stack[stackpointer];   
}

stack_full()
{
 if(stackpointer == STACK_SIZE)
 {
 return 1;
 }  
 return 0;          
}

stack_empty()
{
 if(stackpointer == 0)
 {
  return 1;   
 }
 else
 {
  return 0;    
 }
}

void print_stack()
{
 int i;
 printf("\nStack-Ansicht:\n\n");    
 for(i = 0; i < stackpointer; i++)
 {
  printf("%d ", stack[i]);        
 }
 printf("\n");
}

int main()
{ 
 int auswahl = 0;
 int value;
   
 while(auswahl != 4)
 {
  printf("********************* Menue *********************\n\n");
  if(stack_full() == 0)
  {
   printf("Fuer die Funktion PUSH druecken Sie bitte     <1>\n");
  }
  if(stack_empty() == 0)
  {
   printf("Fuer die Funktion POP  druecken Sie bitte     <2>\n");
  }
  printf("Fuer die Stack-Ansicht druecken Sie bitte     <3>\n");
  printf("Um das Programm zu beenden druecken Sie bitte <4>\n\n");
  printf("Auswahl: < >\b\b");
  scanf("%d", &auswahl);
   
  switch(auswahl)
  {
   case 1: if(stack_full() == 0)
           {
            printf("Wert: ");
            scanf("%d", &value);
            push(value);
           }
           break;
   case 2: if(stack_empty() == 0)
           {
            value=pop();
            printf("%d\n", value);
           }
           break;
   case 3: print_stack();
           break;
  }
 }
  
 printf("\n********** Das Programm wurde beendet ***********\n\n");
  
 system("PAUSE");  
 return 0;
}

[Da Mo (Gast)]

Da ich keine Antworten mehr erhalten habe, gehe ich davon aus, dass die 
aktuelle Umsetzung in Ordnung ist.

Vielen DANK für eure Hilfe!!!

Der nächste Schritt ist der Umbau zu FIFO. Kann ich dazu das aktuelle 
Programm verwenden?

[Daniel F. (df311)]

Do Ma schrieb:
> Der nächste Schritt ist der Umbau zu FIFO. Kann ich dazu das aktuelle
> Programm verwenden?

theoretisch könntest du eine fifo-queue auf basis deines stacks 
implementieren. nach dem umbau des ganze wirst du aber erkennen, dass 
vom ursprünglichen programm nicht mehr viel übrig geblieben ist.

daher mein tipp: fang von vorne an, davon hast du wesentlich mehr

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Do Ma schrieb:
> Da ich keine Antworten mehr erhalten habe, gehe ich davon aus, dass die
> aktuelle Umsetzung in Ordnung ist.

Nein, Du hast nur einen Teil der Ratschläge umgesetzt. Da macht es 
einfach keinen Sinn, als Bittsteller aufzutreten: "Lieber Do Ma, würdest 
Du bitte bitte bitte noch diese oder jene Korrektur einbauen?"