Werde kommenden Montag eine Klausur in Proggen schreiben, und habe Verständniss sowie Syntax Probleme bei der Umsetzung einer ganz speziellen Aufgabe...ich poste sie mal:

b) Sie sollen eine Klasse CharQueue realisieren, welche einzelne Zeichen ( chars ) nach dem FIFO-Prinzip verwaltet. Dabei gilt, dass beliebig viele zeichen verwaltet werden müssen und dafür ein dynamisches Feld ( ws ) verwendet werden muß. Eine erste Klassendefinition sieht dabei wie folgt aus:

class  CharQueue
	{
		char  *ws;
	public:
		void insert( char x );		// fügt Zeichen x ans Ende der 
							// Warteschlange ein
		char get( );				// liefert nächstes Zeichen aus der 
							// Warteschlange
		int  empty();			// 1 = Warteschlange ist leer
							// 0 = Warteschlange ist nicht leer
	};

(1) Realisieren Sie die beiden Konstruktoren, welche die folgenden Variablendefinitionen   erlauben:

		CharQueue  cq;			// leere Wareschlange		(1P)
		CharQueue  cq1(“xyz“ );		// Zeichen x ist Anfang		(1P)
							// z ist Ende der Warteschlange

(2) Realisieren Sie die Methoden get(), insert() und empty() aus obiger (3P)
Klassendefinition!

(3) Überlegen Sie, ob hier ein Destruktor bzw. ein Copy-Konstruktor nötig ist! (3P)
Falls ja, dann realisieren Sie diese! ( Begründungen angeben ! )

Wie lös ich das? Zeichen X ans Ende der Warteschlange? ich versteh leider nur Bahnhof

Danke im voraus!!!

Und dann feststellen, dass Punkt 1 und 2 schonmal ein kleines Problem darstellen

willkommen im C++-Forum.

Ditgez schrieb:

Wie lös ich das? Zeichen X ans Ende der Warteschlange? ich versteh leider nur Bahnhof

wenn Du einen Speicher selber verwaltest, so musst Du drei Dinge über den Speicher wissen.
- wo fängt er an -> das ist leicht, der Pointer 'ws' zeigt darauf
- wo hört er auf, bzw. wie lang ist er
- wo ist die erste Stelle, die vom Benutzer nicht schon belegt ist. Mit anderen Worten, das Ende der Warteschlange.

ws          ende_ws                          endeSpeicher
  |           |                                |
  v           v                                v
+---+---+---+---+---+---+---+---+---+---+---+
| x | y | z |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+

Die beiden Informationen 'ende_ws' und 'endeSpeicher' müssen natürlich noch in der Klasse gemerkt werden. Also

class  CharQueue
{
    char* ws;
    char* ende_ws;
    char* endeSpeicher;

Eine Methdode insert(char x) kopiert dann einfach das x an das Ende und inkrementiert den Zeiger 'ende_ws'. Natürlich muss vorher sichergestellt werden, dass ende_ws noch nicht bei endeSpeicher angekommen ist, also genaug Speicher vorhanden ist.

void CharQueue::insert( char x ) 
{
    if( ende_ws == endeSpeicher )
    {
        vergroessereSpeicher();
    }
    *ende_ws = x;
    ++ende_ws;
}

Gruß Werner

Das ist doch nicht schwer.
Ein normaler Stack mit dem FIFO-Prinzip oder liege ich da falsch?

Stack und FIFO widerspricht sich.

gamebuntu schrieb:

Das ist doch nicht schwer.
Ein normaler Stack mit dem FIFO-Prinzip oder liege ich da falsch?

Stack und FIFO widerspricht sich.

Ja stimmt

ich hab mich vorher mit den Foren Regeln vertraut gemacht, und natürlich hab ich nach keiner Komplettlösung verlangt,

Es ist nur so, daß Einsteigern wie mir das Prinzip von dynamischen Daten nicht so Recht einleuchten will, meistens findet man das Heap Beispiel(Stichwort Eigenititiative) , was leider nicht sehr zugänglich ist

wie ein Beispiel mit was gegenständlicherem wie zB Autos...kennt jemand von euch ein Link oder änhliche Beispiele?

es gibt auch noch ein paar Syntax PRobleme die hier und da auftauchen, wär super wenn ihr mir kurz erklären könntet wie ich das zu verstehen hab, ich leg mal los:

String(const char *const) // <---ein Char Konstanten Pointer mit dem //Signalwort const als Namen? ...dachte das widerspricht den Namenskonventionen //ich schreib ja auch nicht int int

String(const String &) //<--- das & hängt doch irgendwie in der Luft sollte //hier keine Variable folgen damit der Compiler weiss welche Adresse gemeint //sein soll?

So das wars dann aber mit den Ungereimtheiten

Nochmals vielen Dank an Walter Salomon

String(const char *const) // <---ein Char Konstanten Pointer mit dem //Signalwort const als Namen? ...dachte das widerspricht den Namenskonventionen //ich schreib ja auch nicht int int

String(const String &) //<--- das & hängt doch irgendwie in der Luft sollte //hier keine Variable folgen damit der Compiler weiss welche Adresse gemeint //sein soll?

Das sind nur Deklarationen (vermutliche von Konstruktoren einer Klasse String???).

Bei Deklarationen kannst du den Namen der Variablen weglassen, da der Compiler nur den Typ kennen muss.

z.B. reicht

void foo(int&, float);

als Deklaration aus, während die Definition dann die Variablennamen enthält und verwendet.

void foo(int& myIntRef, float myFloat) 
{
    // mach was mit myInt und myFloat
}

Und noch als Tipp bezüglich der ersten Deklaration aus deiner Frage: Ein Zeiger selbst kann const sein, oder der Zeiger zeigt auf einen const Wert, oder beides kann zutreffen, d.h. ein const Zeiger auf einen const Wert.