3. Fragen zu dyn. Datenstruktur

Fragen zu dyn. Datenstruktur

  • ?

    Hallo zusammen,

    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ß

    0
  • E

    1. Brauchst du nicht, ist optional.
    2. Damit die Methode auch aus einer const Datenstruktur aus aufgerufen werden kann. Sozusagen eine Garantie, dass die Methode *this nicht verändert.
    3. Das ist ein Default-Wert.
    4. Der Zeiger zeigt dann auf ein Array, welches mit new[] reserviert wurde.
    5. Ich verstehe die Frage nicht ganz, sorry.
    0
  • B

    1. S bezeichnet die Größe des im Konstruktor erstellten Arrays buffer. Wenn es nicht const ist, kann es theoretisch geändert werden, der Buffer würde seine Größe aber nicht ändern, const verhindert, dass S irgendwann nicht mehr die Größe des Buffers enthält.
    2. Solltest Du auf die Idee kommen, ein konstantes Objekt anzulegen mit zB

    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.

    0
  • ?

    Super!

    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ß

    0
  • L

    Es handelt sich um eine einfache struktur. Das ganze ist aber sehr complex geschreiben worden. (oder ich hab was übersehen).

    -> Stack

    0
  • ?

    Hi!

    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ß

    0
  • L

    Also wie ich es sehe ist das etweder eine sehr schlechte Queue, ein mislungener stack, oder ein unaufgeklärtes stück an Buchstaben und Zeichen.

    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.

    0
  • W
     

    Datenstruktur test();

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

    0
  • E

    Das ist eine als Ringpuffer implementierte Queue: http://de.wikipedia.org/wiki/Warteschlange_(Datenstruktur)#Ringpuffer

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

    0
Anmelden zum Antworten