Hilfe
Neues Thema
Antworten
hier mal der teil der aufgabe, bei dem ich nich weiter weiß:
3. Einlesen der Textdatei und Abspeicherung der einzelnen Textzeilen der Datei.
• Die Verwaltung der eingelesenen Zeilen erfolgt über ein Feld mit 'Zeiger auf char'-Elementen.
• Die eigentlichen Stringvariablen (char-Felder) für die einzelnen Zeilen sind zur Laufzeit des
Programms mit malloc oder calloc dynamisch zu erzeugen. Diese dynamischen Strings dürfen
nur die für die jeweilige Zeile benötigte Größe strlen(..)+1 haben.
• Das Lesen von jeweils einer Zeile aus der Textdatei erfolgt mit dem gelieferten
Unterprogramm GetFileLine, das sich in der Programm-Bibliothek fileread.h/cpp
befindet.
char* GetFileLine( char* PtrFileName, char*PtrTextBuf, int TextBufSize );
Die Funktion liefert bei jedem Aufruf eine Zeile der Textdatei. Als Rückgabewert wird ein
Zeiger auf das erste Zeichen der Textzeile, bzw. bei Öffnungsfehler oder Dateiende die
Konstante NULL geliefert.
Die genaue Vorgehensweise kann der Datei fileread.h entnommen werden.
----
erste versuche ergaben folgendes:
#include
#include
#include
int main (void)
{
char *zeile;
zeile = (char*) calloc (25, sizeof(char));
do {
getFileLine("testtext", zeile, 100);
puts(zeile);
printf("\n%c\n", zeile[0]);
} while (zeile != NULL);
getchar();
free (zeile);
return 0;
}
-----
irgendwie haut das alles gar nicht hin. ich hab kein plan.
hier mal die beiden dateien fileread.h und fileread.cpp:
//**************************************************
**************************
// >fileread.h : Deklaration Liefere bei jedem Aufruf
// fileread.cpp: Definition eine Zeile einer Textdatei
//==================================================
==========================
// Projekt: universelles Modul (Bibliothek)
// Autor :
// Version: 2.0
// 1.0 07.12.2000 Urversion
// 2.0 19.02.2005 neu: Aufrufmodus offene Datei schliessen,
// Umstrukturierung des Moduls auf State-Machine
//
// Beschreibung: siehe unten
// Compiler : Borland C++ V 5.01
//**************************************************
**************************
//**************************************************
**************************
// getFileLine() : eine Dateizeile einer Texdatei lesen und zurueckliefern
//**************************************************
**************************
// Eingang:
// ========
// ptrFileName Zeiger auf den Dateinamen der zu lesenden Textdatei.
// ptrTextBuf Zeiger auf char-Feld mit mindestens TextBufSize Elementen.
// - Es werden alle Zeichen einer Dateizeile maximal jedoch
// TextBufSize-1 Zeichen einer Dateizeile gelesen.
// - Das Zeilenende-Zeichen '\n' wird nicht in den Zielstring
// uebernommen.
// - Wenn die Dateizeile laenger als TextBufSize-1 Zeichen ist,
// gehen die restlichen Zeichen der Dateizeile verloren.
// textBufSize Groesse des char-Feldes (maximale Zeichenzahl+'\0').
//
// Ein Lesevorgang kann jederzeit beendet werden, indem die Funktion beim
// Auruf in einem der beiden Zeiger den Wert NULL erhaelt. Eine offene Datei
// wird in diesem Fall geschlossen.
// Die Puffergroesse muss groesser 2 sein, es wird also immer mindestens
// 1 Zeichen einer Dateizeile gelesen.
//
// Ausgang:
// ========
// return Zeigerkonstante NULL bei Datei-Oeffnungsfehler oder Dateiende
// Wert alles ok: Adresse des 1. gelesenen Zeichens (&PtrTextBuf[0])
//**************************************************
**************************
#ifndef FILEREAD_H // ggf. Makroname definieren, damit die Datei bei
#define FILEREAD_H // mehrfach-includes nur einmal eingefuegt wird
char* getFileLine( char* ptrFileName, char* ptrTextBuf, int textBufSize );
#endif // Ende der bedingten Compilierung
// Ende Datei fileread.h
-------------------------------------------
//**************************************************
**************************
// fileread.h : Deklaration Liefere bei jedem Aufruf
// >fileread.cpp: Definition eine Zeile einer Textdatei
//==================================================
==========================
// Projekt: universelles Modul (Bibliothek)
// Autor :
// Version: 2.0
// 1.0 07.12.2000 Urversion
// 2.0 19.02.2005 neu: Aufrufmodus offene Datei schliessen,
// Umstrukturierung des Moduls auf State-Machine
//
// Beschreibung: siehe unten
// Compiler : Borland C++ V 5.01
//**************************************************
**************************
//**************************************************
**************************
// getFileLine() : eine Dateizeile einer Texdatei lesen und zurueckliefern
//**************************************************
**************************
// Eingang:
// ========
// ptrFileName Zeiger auf den Dateinamen der zu lesenden Textdatei.
// ptrTextBuf Zeiger auf char-Feld mit mindestens TextBufSize Elementen.
// - Es werden alle Zeichen einer Dateizeile maximal jedoch
// TextBufSize-1 Zeichen einer Dateizeile gelesen.
// - Das Zeilenende-Zeichen '\n' wird nicht in den Zielstring
// uebernommen.
// - Wenn die Dateizeile laenger als TextBufSize-1 Zeichen ist,
// gehen die restlichen Zeichen der Dateizeile verloren.
// textBufSize Groesse des char-Feldes (maximale Zeichenzahl+'\0').
//
// Ein Lesevorgang kann jederzeit beendet werden, indem die Funktion beim
// Auruf in einem der beiden Zeiger den Wert NULL erhaelt. Eine offene Datei
// wird in diesem Fall geschlossen.
// Die Puffergroesse muss groesser 2 sein, es wird also immer mindestens
// 1 Zeichen einer Dateizeile gelesen.
//
// Ausgang:
// ========
// return Zeigerkonstante NULL bei Datei-Oeffnungsfehler oder Dateiende
// Wert alles ok: Adresse des 1. gelesenen Zeichens (&PtrTextBuf[0])
//**************************************************
**************************
#include "fileread.h" // eigene Headerdatei einfuegen
#include <stdio.h> // C-I/O-Bibliothek : FILE, fopen(), flose(), fgets()
#include <string.h> // C-String-Bibliothek: strlen()
// Vereinbarung von Konstanten zur Steuerung des Lesevorgangs
//**************************************************
**************************
enum { FS_FILE_IS_CLOSED, FS_FILE_IS_OPEN }; // Datei -Status
enum { AS_IDLE, AS_OPEN_FILE, AS_CLOSE_FILE, AS_GET_LINE }; // Aktions-Status
//**************************************************
**************************
char* getFileLine( char* ptrFileName, char* ptrTextBuf, int textBufSize ) {
static int fileStatus = FS_FILE_IS_CLOSED; // File-Status
static int actionStatus = AS_IDLE; // Aktions-Status: Ruhelage
static FILE* fp = NULL; // Dateizeiger
auto char* ptrReturn = NULL; // Rueckgabe-Zeiger
auto int iLastChar; // Index letztes Zeichen einer Zeile
auto int c; // ueberzaehlige Zeichen einer Zeile entfernen
// State-Machine: durchzufuehrende Aktion bestimmen
if( ptrFileName == NULL || ptrTextBuf == NULL || textBufSize < 2 )
actionStatus = AS_CLOSE_FILE; // Nutzer will Datei schliessen
else if( fileStatus == FS_FILE_IS_OPEN )
actionStatus = AS_GET_LINE; // normaler Betrieb: Dateizeile liefern
else if( fileStatus == FS_FILE_IS_CLOSED )
actionStatus = AS_OPEN_FILE; // neue Datei: Beginn eines Lesezyklusses
else
actionStatus = AS_IDLE; // Ruhelage: keine Aktion
// State-Machine: Aktionen ausfuehren
// Achtung: bedingte u. unbedingte implizite Zweiguebergaenge
// Die case-Reihenfolge darf nicht veraendert werden.
switch( actionStatus ) {
case AS_OPEN_FILE:
fp = fopen( ptrFileName, "rt" ); // Textdatei fuer Lesen oeffnen
if( fp != NULL ) // Oeffnung erfolgreich: weiter mit case AS_GET_LINE
{ fileStatus = FS_FILE_IS_OPEN; actionStatus = AS_GET_LINE; }
else // Oeffnung fehlgeschlagen: kein Lesen -> Return = NULL
{ actionStatus = AS_IDLE; break; }
case AS_GET_LINE:
if( ptrReturn = fgets(ptrTextBuf, textBufSize, fp) ) {
iLastChar = strlen(ptrTextBuf)-1; // Index letztes Zeichen
// im String \n entfernen oder restl. Zeichen Dateizeile ueberlesen
if( ptrTextBuf[iLastChar] == '\n' ) ptrTextBuf[iLastChar] = '\0';
else while( c=fgetc(fp), c != '\n' && c != EOF ) /* leer */;
break; // alles ok: gelesene Zeile zurückgeben
}
else /*leer*/ // Dateiende erreicht: weiter mit case AS_CLOSE_FILE
case AS_CLOSE_FILE:
if( fileStatus == FS_FILE_IS_OPEN )
{ fclose(fp); fp = NULL;
fileStatus = FS_FILE_IS_CLOSED; actionStatus = AS_IDLE; }
break;
case AS_IDLE: default: // Ruhelage: keine Aktion
break;
}; // switch( actionStatus ) { ...
return ptrReturn; // alles ok: Adresse String, Fehler o. EOF: NULL
} // getFileLine()
// Ende Datei fileread.cpp
-------------------------------------------------------
Die programminterne Datenstruktur
char-Zeigerfeld ZZF
char* [] mit malloc oder calloc erzeugte dynamische Strings (char [ ]), Speicherplatz 1.. 80 Zeichen + '\0'
[0] ----------> Dieses ist der Beispieltext fuer das Text-Analyse-Programm. Wir wollen\0
[1] ----------> hoffen, dass er richtig ausgewertet wird und alle Ergebnisse korrekt\0
[2] ----------> sind !\0
[3] ----------> \0
[4] ----------> Aehnliche, natuerlich kompliziertere, Analyse-Programme werden in der\0
[5] ----------> Wissenschaft von Linguisten eingesetzt, um die Characteristika ein-\0
[6] ----------> zelner Sprachen zu untersuchen.\0
[7] NULL Ende des Beispieltextes, Ende der Textanalyse
alle restlichen Feldelemente enthalten die Zeigerkonstante NULL
[25] NULL char* ein Element mehr als maximal Textzeilen möglich sind, Zeiger immer NULL , Endeerkennung, wenn Feld voll
Beachten: Die einzelnen dynamischen Strings [0]..[n] liegen nicht fortlaufend im Arbeitsspeicher, da die Speicherreservierung durch
Einzelaufrufe von malloc oder calloc erfolgt. Lediglich die Zeichen eines Strings sind fortlaufend im Speicher (Feld).
ZZF[0] char * die Adresse des ersten Zeichens von String 1
ZZF[0][0] char das 1. Zeichen von String 1 (D)
ZZF[1][5] char das 6. Zeichen von String 2 (n)
Dieser Beitrag wurde von moniduse bearbeitet: 07. Januar 2006 - 00:09
Nach oben
