gosewehrsi99061/Info2V
1
0
Fork 0
generated from freudenreichan/info2Praktikum-Wortsalat
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Kommentierte und getestete Version von input.c

Browse Source
This commit is contained in:
Pia Keil 2025-11-04 20:57:51 +01:00
parent 3d2f08997d
commit eb4876909f
3 changed files with 65 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
Start_Windows/input.c
View File

@ -2,127 +2,122 @@
#include <string.h> #include <string.h>
#include <ctype.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) 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; // aktuelles Zeichen aus der Datei
int c; size_t len = 0; // Anzahl der bisher eingelesenen Zeichen im aktuellen Wort
size_t len = 0;
// (2) Sicherheitscheck: sind die Parameter überhaupt gültig? // --- Sicherheitsprüfung: Sind die Übergabeparameter gültig? ---
if (file == NULL || buffer == NULL || bufferSize == 0) 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 // --- 1. Führende Trennzeichen überspringen ---
// -> solange nur Komma, Semikolon oder Whitespace kommt, weiter lesen // 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) while ((c = fgetc(file)) != EOF)
{ {
if (c == ',' || c == ';' || isspace((unsigned char)c)) if (c == ',' || c == ';' || isspace((unsigned char)c))
{ {
continue; // Trennzeichen -> noch kein Wort continue; // noch kein Buchstabe -> weiter zum nächsten Zeichen
} }
else 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) if (c == EOF)
{ {
return 0; return 0;
} }
// (5) Ersten Buchstaben des Wortes in den Buffer schreiben // --- 3. Erstes Zeichen des Wortes in den Buffer schreiben ---
buffer[len++] = (char)c; // 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) 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)) if (c == ',' || c == ';' || isspace((unsigned char)c))
{ {
break; 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) 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 // --- 5. String beenden ---
buffer[len] = '\0'; buffer[len] = '\0'; // Nullterminator am Ende -> macht aus dem Array einen C-String
// (9) 1 zurückgeben: es wurde erfolgreich ein Wort gelesen // --- 6. Erfolg melden ---
return 1; 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) 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; // zählt, wie viele Wörter gefunden wurden
unsigned int count = 0; char buffer[MAX_WORD_LEN]; // Zwischenspeicher für EIN Wort (kommt aus der Hilfsfunktion)
// (2) Temporärer Puffer für EIN Wort // --- Sicherheitsprüfung ---
char buffer[MAX_WORD_LEN]; // Datei darf nicht NULL sein, das Array muss existieren, und es muss Platz vorhanden sein.
// (3) Sicherheitscheck: Datei, Ziel-Array und maxWordCount prüfen
if (file == NULL || words == NULL || maxWordCount == 0) if (file == NULL || words == NULL || maxWordCount == 0)
{ {
return 0; return 0; // ungültige Eingaben -> keine Wörter gelesen
} }
// (4) Hauptschleife: // --- Hauptschleife ---
// Solange noch Platz im words-Array ist // Solange:
// UND readSingleWord() noch ein Wort liefert // - noch Platz im 'words'-Array ist (count < maxWordCount)
// - UND readSingleWord() ein neues Wort liefern kann
while (count < maxWordCount && readSingleWord(file, buffer, sizeof(buffer))) while (count < maxWordCount && readSingleWord(file, buffer, sizeof(buffer)))
{ {
// (5) Wort aus dem Buffer sicher ins nächste freie Feld von 'words' kopieren // --- 1. Wort aus dem Buffer ins große Array kopieren ---
// -> words[count] ist der nächste freie Platz // strcpy wäre unsicher -> strncpy schützt vor Überlauf
strncpy(words[count], buffer, MAX_WORD_LEN); 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'; 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++; 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; 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
View File

Binary file not shown.

1
Start_Windows/unit_tests.c
View File

@ -141,3 +141,4 @@ int main(void) {
return result; return result;
} }