generated from freudenreichan/info2Praktikum-Wortsalat
Kommentierte und getestete Version von input.c
This commit is contained in:
Pia Keil
parent
3d2f08997d
commit
eb4876909f
@ -2,127 +2,122 @@
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
|
||||
//
|
||||
// HILFSFUNKTION: liest genau EIN Wort aus der Datei in 'buffer'
|
||||
// Rückgabe: 1 = Wort gelesen, 0 = kein Wort mehr (EOF oder Fehler)
|
||||
//
|
||||
/*
|
||||
* ------------------------------------------------------------
|
||||
* HILFSFUNKTION:
|
||||
* Liest genau EIN Wort aus einer Datei und speichert es in 'buffer'.
|
||||
*
|
||||
* - Trennt Wörter anhand von Komma, Semikolon oder Leerzeichen.
|
||||
* - Wandelt alle Buchstaben in GROSSBUCHSTABEN um (damit Tests passen).
|
||||
* - Gibt 1 zurück, wenn ein Wort gefunden wurde.
|
||||
* - Gibt 0 zurück, wenn nichts mehr zu lesen ist (EOF oder Fehler).
|
||||
* ------------------------------------------------------------
|
||||
*/
|
||||
static int readSingleWord(FILE *file, char *buffer, size_t bufferSize)
|
||||
{
|
||||
// (1) Lokale Variablen: c = aktuelles Zeichen, len = Länge des Wortes im Buffer
|
||||
int c;
|
||||
size_t len = 0;
|
||||
int c; // aktuelles Zeichen aus der Datei
|
||||
size_t len = 0; // Anzahl der bisher eingelesenen Zeichen im aktuellen Wort
|
||||
|
||||
// (2) Sicherheitscheck: sind die Parameter überhaupt gültig?
|
||||
// --- Sicherheitsprüfung: Sind die Übergabeparameter gültig? ---
|
||||
if (file == NULL || buffer == NULL || bufferSize == 0)
|
||||
{
|
||||
return 0;
|
||||
return 0; // nichts tun, wenn Datei oder Speicher ungültig ist
|
||||
}
|
||||
|
||||
// (3) Führende Trennzeichen überspringen
|
||||
// -> solange nur Komma, Semikolon oder Whitespace kommt, weiter lesen
|
||||
// --- 1. Führende Trennzeichen überspringen ---
|
||||
// Solange Kommas, Semikolons oder Leerzeichen kommen, einfach weiter lesen.
|
||||
// Erst wenn ein anderes Zeichen kommt, fängt das Wort an.
|
||||
while ((c = fgetc(file)) != EOF)
|
||||
{
|
||||
if (c == ',' || c == ';' || isspace((unsigned char)c))
|
||||
{
|
||||
continue; // Trennzeichen -> noch kein Wort
|
||||
continue; // noch kein Buchstabe -> weiter zum nächsten Zeichen
|
||||
}
|
||||
else
|
||||
{
|
||||
break; // erstes Nicht-Trennzeichen -> Start des Wortes
|
||||
break; // erstes Nicht-Trennzeichen gefunden -> Wort beginnt hier
|
||||
}
|
||||
}
|
||||
|
||||
// (4) Wenn direkt EOF kommt, bevor ein Wort beginnt: kein Wort mehr vorhanden
|
||||
// --- 2. Falls direkt EOF (End of File) erreicht wurde, kein Wort mehr vorhanden ---
|
||||
if (c == EOF)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// (5) Ersten Buchstaben des Wortes in den Buffer schreiben
|
||||
buffer[len++] = (char)c;
|
||||
// --- 3. Erstes Zeichen des Wortes in den Buffer schreiben ---
|
||||
// Dabei gleich in Großbuchstaben umwandeln
|
||||
char upperChar = (char) toupper((unsigned char) c);
|
||||
buffer[len++] = upperChar;
|
||||
|
||||
// (6) Rest des Wortes lesen, bis wieder ein Trennzeichen oder EOF kommt
|
||||
// --- 4. Rest des Wortes lesen, bis ein Trennzeichen oder das Dateiende erreicht ist ---
|
||||
while ((c = fgetc(file)) != EOF)
|
||||
{
|
||||
// Trennzeichen: Wort ist zu Ende
|
||||
// Wenn Komma, Semikolon oder Leerzeichen -> Wort ist zu Ende
|
||||
if (c == ',' || c == ';' || isspace((unsigned char)c))
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
// (7) Nur schreiben, solange noch Platz ist (für das abschließende '\0')
|
||||
// Nur schreiben, solange noch Platz im Buffer ist (letztes Zeichen für '\0' reservieren!)
|
||||
if (len < bufferSize - 1)
|
||||
{
|
||||
buffer[len++] = (char)c;
|
||||
upperChar = (char) toupper((unsigned char) c); // Zeichen in Großbuchstaben
|
||||
buffer[len++] = upperChar; // Zeichen im Buffer speichern
|
||||
}
|
||||
// Wenn kein Platz mehr ist, werden die restlichen Zeichen des Wortes ignoriert
|
||||
// Wenn kein Platz mehr, restliche Zeichen ignorieren (Vermeidung von Speicherfehlern)
|
||||
}
|
||||
|
||||
// (8) String terminieren: am Ende ein '\0' setzen, damit es ein gültiger C-String ist
|
||||
buffer[len] = '\0';
|
||||
// --- 5. String beenden ---
|
||||
buffer[len] = '\0'; // Nullterminator am Ende -> macht aus dem Array einen C-String
|
||||
|
||||
// (9) 1 zurückgeben: es wurde erfolgreich ein Wort gelesen
|
||||
return 1;
|
||||
// --- 6. Erfolg melden ---
|
||||
return 1; // 1 = Wort erfolgreich eingelesen
|
||||
}
|
||||
|
||||
//
|
||||
// HAUPTFUNKTION: liest ALLE Wörter aus der Datei und speichert sie im Array 'words'
|
||||
// Rückgabe: wie viele Wörter tatsächlich eingelesen wurden
|
||||
//
|
||||
/*
|
||||
* ------------------------------------------------------------
|
||||
* HAUPTFUNKTION:
|
||||
* Liest ALLE Wörter aus einer Datei und speichert sie in 'words'.
|
||||
*
|
||||
* - Ruft die Hilfsfunktion 'readSingleWord()' mehrfach auf,
|
||||
* um ein Wort nach dem anderen zu lesen.
|
||||
* - Kopiert jedes gefundene Wort in das große 'words'-Array.
|
||||
* - Zählt, wie viele Wörter tatsächlich gefunden wurden.
|
||||
* ------------------------------------------------------------
|
||||
*/
|
||||
int readWords(FILE *file, char words[][MAX_WORD_LEN], unsigned int maxWordCount)
|
||||
{
|
||||
// (1) Zähler, wie viele Wörter bereits eingelesen wurden
|
||||
unsigned int count = 0;
|
||||
unsigned int count = 0; // zählt, wie viele Wörter gefunden wurden
|
||||
char buffer[MAX_WORD_LEN]; // Zwischenspeicher für EIN Wort (kommt aus der Hilfsfunktion)
|
||||
|
||||
// (2) Temporärer Puffer für EIN Wort
|
||||
char buffer[MAX_WORD_LEN];
|
||||
|
||||
// (3) Sicherheitscheck: Datei, Ziel-Array und maxWordCount prüfen
|
||||
// --- Sicherheitsprüfung ---
|
||||
// Datei darf nicht NULL sein, das Array muss existieren, und es muss Platz vorhanden sein.
|
||||
if (file == NULL || words == NULL || maxWordCount == 0)
|
||||
{
|
||||
return 0;
|
||||
return 0; // ungültige Eingaben -> keine Wörter gelesen
|
||||
}
|
||||
|
||||
// (4) Hauptschleife:
|
||||
// Solange noch Platz im words-Array ist
|
||||
// UND readSingleWord() noch ein Wort liefert
|
||||
// --- Hauptschleife ---
|
||||
// Solange:
|
||||
// - noch Platz im 'words'-Array ist (count < maxWordCount)
|
||||
// - UND readSingleWord() ein neues Wort liefern kann
|
||||
while (count < maxWordCount && readSingleWord(file, buffer, sizeof(buffer)))
|
||||
{
|
||||
// (5) Wort aus dem Buffer sicher ins nächste freie Feld von 'words' kopieren
|
||||
// -> words[count] ist der nächste freie Platz
|
||||
// --- 1. Wort aus dem Buffer ins große Array kopieren ---
|
||||
// strcpy wäre unsicher -> strncpy schützt vor Überlauf
|
||||
strncpy(words[count], buffer, MAX_WORD_LEN);
|
||||
|
||||
// (6) Zur Sicherheit: letztes Zeichen auf '\0' setzen (falls Wort zu lang war)
|
||||
// --- 2. Sicherstellen, dass das Wort immer korrekt endet ---
|
||||
// Wenn das Wort genau MAX_WORD_LEN Zeichen lang war,
|
||||
// könnte der '\0' durch strncpy fehlen -> hier wird er garantiert gesetzt.
|
||||
words[count][MAX_WORD_LEN - 1] = '\0';
|
||||
|
||||
// (7) Zähler erhöhen -> nächstes Wort kommt in words[count+1]
|
||||
// --- 3. Zähler erhöhen -> nächstes Wort kommt in words[count+1] ---
|
||||
count++;
|
||||
}
|
||||
|
||||
// (8) Anzahl der eingelesenen Wörter an den Aufrufer (z.B. main) zurückgeben
|
||||
// --- Schleife beendet: entweder kein Wort mehr oder Array ist voll ---
|
||||
// Rückgabe: Anzahl der tatsächlich eingelesenen Wörter
|
||||
return count;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//Erklärung des Codes für Präsentation:
|
||||
|
||||
//In main wird eine Datei geöffnet und ein zweidimensionales Array words angelegt.
|
||||
//Dann wird unsere Funktion readWords(file, words, MAX_NUMBER_OF_WORDS) aufgerufen.
|
||||
|
||||
//In readWords haben wir zuerst einen Zähler count, der mitzählt, wie viele Wörter wir schon eingelesen haben, und einen temporären Buffer für ein einzelnes Wort.
|
||||
//Danach kommt eine while-Schleife:
|
||||
//while (count < maxWordCount && readSingleWord(file, buffer, sizeof(buffer)))
|
||||
//Die Schleife läuft so lange, wie noch Platz im Array ist und unsere Hilfsfunktion readSingleWord immer wieder ein neues Wort aus der Datei liefert.
|
||||
|
||||
//readSingleWord kümmert sich nur darum, ein einzelnes Wort zu lesen:
|
||||
//Sie überspringt erst alle Trennzeichen wie Kommas, Semikolons oder Leerzeichen,
|
||||
//merkt sich dann das erste Nicht-Trennzeichen als Wortanfang und liest so lange weiter, bis wieder ein Trennzeichen kommt oder die Datei zu Ende ist.
|
||||
//Das gelesene Wort landet im buffer und wird mit '\0' beendet.
|
||||
//Wenn ein Wort gefunden wurde, gibt readSingleWord 1 zurück, sonst 0.
|
||||
|
||||
//Zurück in readWords wird jedes Wort aus dem Buffer mit strncpy in das Array words[count] kopiert.
|
||||
//Danach wird count erhöht, sodass das nächste Wort an die nächste freie Stelle geschrieben wird.
|
||||
//Wenn keine Wörter mehr gelesen werden können, gibt readWords die Gesamtzahl der eingelesenen Wörter zurück.
|
||||
}
|
||||
BIN
Start_Windows/input_tests.exe
Normal file
BIN
Start_Windows/input_tests.exe
Normal file
Binary file not shown.
@ -141,3 +141,4 @@ int main(void) {
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user