hätt da n paar fragen
mein quelltext erstma

#include <iostream>
#include <conio.h>

using namespace std;

class stack
{
public:
    stack(int groesse);
    ~stack();
    int push(char eintrag);
	int loeschen(); //
    char pop();
    bool istLeer();
    bool istVoll();
    void inhalt_anzeigen();
    void groesse_anzeigen();
private:
    char *element;            // Zeiger auf Array
    int n;                    // Anzahl der Elemente im Stack
    int max;                // maximale Groesse des Stacks
};

stack::stack(int groesse)
{
    n = 0;
    max = groesse;
    element = new char[groesse]; // dynamisches Element erzeugen, new und delete bewerkstelligen die dynamische Speicherbelegung
}

int stack::loeschen()
{
	n=0;
	return 0;
}

stack::~stack()
{ 
    delete [] element;        // dynamisches Element l?schen
}        

bool stack::istLeer()
{ 
    return (n == 0);
}

bool stack::istVoll()
{ 
    return (n == max);
}

int stack::push(char eintrag)
{
    if (istVoll()==1)
    return -1;
    element[n] = eintrag;
    n++;
    return 0;
}

char stack::pop()            
{
    if (istLeer()==1)
        return -1;
    else 
      n--;
	{

        return (element[n]);

	}
}

void stack::inhalt_anzeigen()
{

    cout << "\n  ";
    for (int i=0; i<=n-1; i++)
        cout << element[i] << " ";
    for (int k=0; k<=(max-n); k++)             //ausfäüllen der plaetze mit x
		cout<<"x";

    if (istVoll()==1)
        cout << "\n Stack ist voll!";
    if (istLeer()==1)
        cout << "\n Stack ist leer!";

}

void stack::groesse_anzeigen()
{
    cout << "\n Groesse des Stacks: " << max;
}

int main ()
{

    int auswahl, groesse, antwort, x=0;
    char zeichen;

	anfang:
    cout << " Bitte geben Sie die Groesse des Stacks ein (1-50) 0=Ende: ";
    cin >> groesse;
	if (groesse!=0)
	{
		if (groesse<51)
		{

    cout << "\n";
    stack stack(groesse);   //Objekt stack der Klasse stack erzeugen

    while (1 != 0)
    {
      system ("cls");
      cout << "\n\n ----------------------------";
      cout << "\n            MENUE \n";
      cout << " ----------------------------";
      cout << "\n 1: Zeichen in dem Stack ablegen";
      cout << "\n 2: Zeichen aus dem Stack holen";
      cout << "\n 3: Inhalt des Stacks anzeigen und loeschen";
      cout << "\n 4: Stack loeschen";
      cout << "\n 0: Ende";
      cout << "\n ----------------------------";
      cout << "\n\n Bitte Nummer eingeben: ";
      cin  >> auswahl;
      switch (auswahl)
      {
          case (1):
              cout << "\n Bitte geben Sie das Zeichen ein, welches in dem Stack abgelegt werden soll:";
              cin >> zeichen;
              antwort=stack.push(zeichen);
              if (antwort==-1)
                  cout << "\n Das Zeichen konnte nicht abgelegt werden, da der Stack voll ist!";

              else 
                  cout << "\n Das Zeichen '" << zeichen << "' wurde erfolgreich im Stack abgelegt!";
				stack.inhalt_anzeigen();

              while ( !_kbhit());
          break;

          case (2):
              zeichen=stack.pop();
              if (zeichen==-1)
              {
                  cout << "\n Es konnte kein Zeichen aus dem Stack geholt werden, da der Stack leer ist!";
              }
              else
                  cout << "\n Sie haben '" << zeichen << "' aus dem Stack geholt";
				stack.inhalt_anzeigen();
              getch();
          break;

          case (3):

              stack.inhalt_anzeigen();
			  stack.loeschen();
              getch();

          break;

          case (4):
			  stack.loeschen();
              /*stack.groesse_anzeigen();
              getch();*/
          break;

          case (0):
              exit (0);
          break;
      }
    }
	}
	else 
		cout<<"Falsche eingabe!!!\n\n";
	goto anfang;
	}

	else
    return 0;
}

wie kann ich beim drücken der 2, also lesen eines zeichens, immer das älteste zeichen afn bildschirm bekommen, und bei weiteren eingabe von nem zeichen erstma den stack zuende auffüllen und erst dann von anfang wieder starten (beim auslesen wird das zeichen gelöscht)??

wie kann ich beim drücken der 2, also lesen eines zeichens, immer das älteste zeichen afn bildschirm bekommen, und bei weiteren eingabe von nem zeichen erstma den stack zuende auffüllen und erst dann von anfang wieder starten (beim auslesen wird das zeichen gelöscht)??

Versteh' dich nicht.

snoopy9134 schrieb:

und falls mir einer n tipp geben könnte, wie ich die leeren plätze im stack mit irgendeinem zeichen z.B.x ausfülle die dann sozusagen den freien speicher darstellen??

Dann hast du IMHO den Sinn eines Stacks missverstanden, denn auf dem Stack gibt es in der Regel keinen freien Speicher. Er wächst mit seinem Inhalt.

snoopy9134 schrieb:

hab jetzt soweit mitm ausfüllen mit x hingekriegt, weiss aber net wies sich darauf auswirkt, wenn ich das erste zeichen anstatt des letzten löschen würde!!!

Versteh' dich auch hier nicht.

Greetz, Swordfish

ps. stack is nur ne klassenbezeichnung, ich hab hier ein arrayfeld dessen grösse ich am anfang festlege, in das ich zeichen reinschreiben und die ich danach auslesen(löschen) kann!

ich geb am anfang eine bestimmte grösse an, (wieviel zeichen ich reinschreiben darf)

Jaaaa, das weiß ich auch, wenn ich deinen Code anschaue

snoopy9134 schrieb:

mit der 2 kann ich die zeichen dann auslesen, is aber im moment so das wenn ich 3 zeichen nacheinander eingeb, dass dann immer das letzte gelöscht wird

Jaaaaaaaa, das weiß ich _auch_ wenn ich deinen Code anschaue, denn das Problem ist nicht der Code, sondern die Fragestellung.

snoopy9134 schrieb:

(eingegeben 1 2 3, beim auslesen wird die 3 gelöscht)

Jaaaaaaaaaaaa, ist's 'n Stack sollt's auch so sein.

snoopy9134 schrieb:

und ich muss es so hinkriegen dass erst die eins, danach die zwei und s.w gelöscht werden!!!

...dann willst du 'ne Queue und keinen Stack

Es gibt da zwei unterschiedliche Prinzipien:

LIFO (Last in First out) -> Stack

zB:
push( 1 ) -> 1
push( 2 ) -> 1, 2
push( 3 ) -> 1, 2, 3
pop( ) -> 3
pop( ) -> 2
pop( ) -> 1

FIFO (First in First out) -> Queue

enqueue( 1 ) -> 1
enqueue( 2 ) -> 1, 2
enqueue( 3 ) -> 1, 2, 3
dequeue( ) -> 1
dequeue( ) -> 2
dequeue( ) -> 3

Klaro?

Einen Stack könnte man zB. so implementieren:

#include <ctime>
#include <cstdlib>
#include <iostream>

using namespace std;

class stack {

    friend ostream& operator<<( ostream &os, stack &k );	

    private:

        int *data;
        size_t size;

    public:

	stack( );
        ~stack( );
        void push( int e );
        int pop( );
};

stack::stack( ) : data( 0 ), size( 0 )
{
}

stack::~stack( )
{
    if( data )
        delete [ ] data;
}

void stack::push( int e )
{
    ++size;
    if( !data ) {
        data = new int[ size ];
    } else {
        int *tmp = new int[ size ];

        for( size_t i = 0; i < ( size - 1 ); ++i )
            tmp[ i ] = data[ i ];

        delete [ ] data;
        data = tmp;
    }
    data[ size - 1 ] = e;
}

int stack::pop( )
{
    if( !data )
        return 0;

    if( size == 1 ) {
        int tmp = data[ 0 ];
        delete [ ] data;
        data = 0;
        size = 0;
        return tmp;
    }

    int *tmp = new int[ size - 1 ];
    int retval = data[ size - 1 ];

    for( size_t i = 0; i < ( size - 1 ); ++i )
        tmp[ i ] = data[ i ];
    delete [ ] data;
    --size;
    data = tmp;

    return retval;
}

ostream& operator<<( ostream &os, stack &s )
{
    for( size_t i = 0; i < s.size; ++i ) {
        os.fill( 0 );
        os.width( 3 );
        os << i;
        os << ": " << s.data[ i ] << endl;
    }
    os << "TOP OF STACK" << endl;
    return os;
}

int main( )
{
    stack s;

    srand( static_cast< unsigned int >( time( 0 ) ) );

    for( int i = 0; i < 18; ++i )
        s.push( rand( ) );

    cout << "The Stack: " << endl << s << endl;
}

Greetz, Swordfish

aber irgendwie krieg ichs net hin

#include <iostream>
#include <conio.h>

using namespace std;

class queue {

    public:
        queue( int groesse );
        ~queue( );
        void enqueue( char eintrag );
        char dequeue( );
        void loeschen( );
        bool istLeer( );
        bool istVoll( );
        void inhalt_anzeigen( );
        void groesse_anzeigen( );

    private:
        char *element;
        int n;
        int max;
};

queue::queue( int groesse ) : n( 0 ), max( groesse )
{
    element = new char[ groesse ];
}

queue::~queue( )
{
    delete [ ] element;
}        

void queue::enqueue( char eintrag )
{
    if( istVoll( ) )
        return;
    element[ n++ ] = eintrag;
}

char queue::dequeue( )            
{
    if( istLeer( ) )
        return -1;

    char rueckgabe = element[ 0 ];

	--n;
    for( size_t i = 0; i < n; ++i )
        element[ i ] = element[ i + 1 ];

    return rueckgabe;
}

void queue::loeschen( )
{
    n = 0;
}

bool queue::istLeer( )
{
    return( n == 0 );
}

bool queue::istVoll( )
{
    return( n == max );
}

void queue::inhalt_anzeigen()
{
    if( istLeer() ) {
        cout << endl << " Queue ist leer!";
        return;
    }

    cout << endl << "  ";
    for( size_t i = 0; i < ( n - 1 ); ++i )
        cout << element[ i ] << ", ";

    cout << element[ n - 1 ];

    if( istVoll() )
        cout << endl << " Queue ist voll!";

    cout << endl << endl;
}

void queue::groesse_anzeigen( )
{
    cout << endl << " Groesse der Queue: " << max;
}

int main ( )
{
    int auswahl;
    char zeichen;
    bool beenden = false;

    cout << "Bitte geben Sie die Groesse des Stacks ein (1-50) 0 = Ende: ";
    do {
        cin >> auswahl;
        if( auswahl == 0 )
        return 0;
    } while( auswahl > 50 );

    queue q( auswahl );

    do {
        system( "cls" );
        cout << endl << endl;
        cout << " -----------------------------------------" << endl;
        cout << "                  MENUE" << endl;
        cout << " -----------------------------------------" << endl;
        cout << " 1: Zeichen in der Queue einreihen" << endl;
        cout << " 2: Zeichen aus der Queue holen" << endl;
        cout << " 3: Inhalt der Queue anzeigen und loeschen" << endl;
        cout << " 4: Queue loeschen" << endl;
        cout << " 0: Ende" << endl;
        cout << " -----------------------------------------" << endl << endl;
        cout << " Bitte Nummer eingeben: ";
        cin  >> auswahl;

        switch( auswahl ) {
            case 1:
                if( q.istVoll( ) ) {
                    cout << endl << " Es kann nichts mehr eingereiht werden da die Queue voll ist!";
                } else {
                    cout << endl << " Bitte geben Sie das Zeichen ein, welches in die Queue eingereiht werden soll: ";
                    cin >> zeichen;
                    q.enqueue( zeichen );
                    cout << endl << " Das Zeichen '" << zeichen << "' wurde erfolgreich in die Queue eingereiht!";
                    q.inhalt_anzeigen( );
                }
                getch( );
                break;

            case 2:
                if( q.istLeer( ) ) {
                    cout << endl << " Es konnte kein Zeichen aus der Queue geholt werden, da die Queue leer ist!";
                } else {
                    cout << endl << " Sie haben '" << q.dequeue( ) << "' aus dem Stack geholt";
                    q.inhalt_anzeigen( );
                }	
                getch( );
                break;

            case 3:
                q.inhalt_anzeigen( );
                q.loeschen( );
                getch( );
                break;

            case 4:
                q.loeschen();
                break;

            case 0:
                beenden = true;
                break;

            default:
                cout<< endl << " Falsche Eingabe!!!" << endl;
                break;
        }
    } while( !beenden );
}

Greetz, Swordfish

mfg blan

was machts fürn sinn nen stack selbter zu programmieren, sowas gibts doch schon in der STL oder?

mfg blan

Übung macht den Meister. Ich schätze so gut wie jeder hat daheim seinen eigenen Vector, seine LinkedList, seinen Stack, Maps usw. rumliegen, nur um mal zu sehen, wie's geht und wo man optimieren kann, wenn's mal drauf ankommt.

MfG

GPC