ich habe folgenden Quelltext:

#include <cstdlib>
#include <iostream>

using namespace std;

class Datenstruktur
{
      private: 
               const unsigned int S; //1. FRAGE: WARUM BRAUCHE ICH HIER CONST?
               int * Buffer; 
               unsigned int R; 
               unsigned int F; 
               unsigned int Num;

               void increment (unsigned int & i) const //2. FRAGE: WARUM WIRD HIER CONST BENÖTIGT? WELCHEN SINN HAT DAS HIER
               {
                    if (++i >= S)       
                       i = 0;
                       cout<< "i hat den WERT:" << i << endl;
               }

               public: 
                       Datenstruktur (unsigned int S = 100) : S(S), Buffer (new int [S]), R(0), F(1), Num(0) { cout << "S ist " << S << endl; }
                       //3. FRAGE: WARUM WIRD HIER S = 100 GESETZT? S WIRD DOCH IN DER MAIN ÜBERGEBEN?
                       //4. FRAGE: WIRD BEI BUFFER EIN NEUES ARRAY MIT "S" ELEMENTEN ANGELEGT? BUFFER IST DANN DER ZEIGER AUF DAS ARRAY?
                       ~Datenstruktur ()
                                      { delete [] Buffer; }

                                      bool full () const { return Num == S; }
                                      bool empty () const { return Num == 0; }
                                      bool enDatenstruktur (int x) 
                                      {
                                           if ( full ())
                                              return false;
                                          increment (R);
                                          cout << "R HAT DEN WERT" << R << endl;
                                          Buffer[R] = x; //5. FRAGE: DA R MIT 0 INITIALISIERT WURDE, WIRD  NACH INCRMENT IN DAS 1. ELEMENT WAS GESCHRIEBEN?
                                                         // DAS BEDEUTET, BUFFER[0] BLEIBT IMMER LEER????? KANN DAS STIMMEN??
                                          ++Num;
                                          return true;
                                      }

                                      int deDatenstruktur () 
                                      {
                                          if ( empty ())
                                             return 0;
                                          int x = Buffer[F]; //siehe Frage 5, ich lösche ja nimals den 0 ten Wert, sondern beginne mit F = 1?
                                          increment (F);
                                          --Num;
                                          return x;
                                          }
};

int main(int argc, char *argv[])
{
    int auswahl = 1;
    int aNr = 1000;
    Datenstruktur test(10);
    do
      {
      cout << endl << "---- AUFTRAG ----" << endl;
      cout << "1. Neuer Autrag" << endl;
      cout << "2. Naechsten Auftrag abarbeiten" << endl;
      cout << "0. Programm beenden" << endl;
      cout << "> ihre Wahl [Return]: ";
      cin >> auswahl;
      cout << endl;
      switch (auswahl)
      {
      case 0:
            break;
      case 1:
            if (test.full ())
               cerr << "ERROR: Datenstruktur overflow" << endl;
            else
             {
                cout << "> Neuer Auftrag erzeugt; AuftragsNr: " << aNr << endl;
                test.enDatenstruktur (aNr);
                aNr++;
              }
              break;

    case 2:
           if (test.empty ())
              cerr << "ERROR: Datenstruktur is empty" << endl;
           else
               cout << "> Auftrag bearbeitet; AuftragsNr: " << test.deDatenstruktur () << endl;
           break;

    default:
            cerr << "ERROR: falsche Auswahl" << endl;
    }
    } while (auswahl != 0);
    while (! test.empty ())
    cout << "Auftrag noch in der test, Nr: " << test.deDatenstruktur () << endl;
    return 1;

    system("PAUSE");
    return EXIT_SUCCESS;
}

Im Text habe ich 5 Fragen hinzugefügt. Würdet ihr mir hier bitte helfen?

Und noch eine Frage: Welche Art von dyn. Datenstruktur handelt es sich?
Mir ist jetzt nur die verkettete Liste bekannt. Aber ist das wirklich eine verkettete Liste? Ich habe ja keinen Nachfolger gespeichert? Und ich lege ja bereits im Vorfeld fest, wie viele Aufträge existieren dürfen?

Danke!

Gruß

const Datenstrukur ds;

dann können für dieses Objekt nur Methoden aufgerufen werden, die auch mit const ausgezeichnet sind und das Objekt nicht verändern.

3. warum? keine Ahnung. Sinn? Ist ein Default-Wert, wenn man das Objekt wie oben gezeigt ohne Argument erstellt, wird einfach 100 genommen.

Ja, ja.

5. wenn einmal das ganze Array vollgeschrieben wurde, gibt increment ja 0 zurück, dann wird also auch Buffer[0] beschrieben.

Danke für die Hilfe!

Jetzt ist nur noch die eine Frage offen:

Und noch eine Frage: Welche Art von dyn. Datenstruktur handelt es sich?
Mir ist jetzt nur die verkettete Liste bekannt. Aber ist das wirklich eine verkettete Liste? Ich habe ja keinen Nachfolger gespeichert? Und ich lege ja bereits im Vorfeld fest, wie viele Aufträge existieren dürfen?

Danke!

Gruß

-> Stack

Danke.

Aber ich glaube Stack ist es nicht, oder?

Wenn ich z.B. 5 Aufträge anlege:

1000
1001
1002
1003
1004

dann werden diese wieder wie folgt abgearbeitet:.

1000
1001
1002
1003
1004

Nennt man das dann Queue?

Was bedeutet dann in diesem Zusammenhang heap? Heap heißt doch einfach, dass die Objekte dynamisch verwaltet werden, oder??

Noch eine Rückfrage an die ursprüngliche Frage:

wenn ich z.B.:

Datenstruktur test();

Habe, dann gibt es mehrere Compiler - Fehler, da

case 1:
            if (test.full ())
               cerr << "ERROR: Datenstruktur overflow" << endl;
            else

Probleme macht.

Weiß jemand warum das so ist? Ich dachte, ich kann auch ein Objekt Datenstruktur ohne Argumente erzeugen?

Danke!!

Gruß

Wird auf jeden Fall in form einer liste gespeichert.
Num zeigt nicht undedingt zum letzten Element, aber eben die Anzahl.
R ist wtf? glaub ich; und will die nächstfreie position angeben. (zum schreiben)
F ist hä?! und gibt an (von element 0 startend), wo wir als nächstes zu lesen haben. (zum lesen)
S ist Size und ist constant, und gibt eben die maximalanzahl der elemente an.

Also... kein Stack und Keine Queue.

ist eine Funktionsdeklaration, selbst wenn es in einer anderen Funktion steht. Mach' die Klammern weg.

Was daran so komisch oder misslungen sein soll, weiß ich nicht (bis auf die sehr unschönen Bezeichner für Attribute und Methoden).