4. Dateiinhalt in struct schreiben

Dateiinhalt in struct schreiben

  • ?

    Hallo,

    ich möchte den Inhalt einer Datei, die ich mittels

    if(configfile = fopen("config.xml", "r")) {

    geöffnet habe, in folgendes struct schreiben:

    struct memory{
    char *content;
    int size;
};

    Wie mache ich das?

    Danke,
    flo

    0
  • D

    einfach einlesen und die struct nach char* casten

    allerdings wird das in Deinem Fall nicht klappen, weil dein memory ein Zeiger ist. heißt also, der liest 4 byte und macht daraus dann den Zeiger auf ein char und dann liest er noch ein int aus..

    0
  • ?

    aha, und was heisst das für mich? kann damit nicht wirklich was anfangen ...

    0
  • K

    Ich würde an Deiner Stelle die Textdatei zeilenweise einlesen, dann kann sie leichter bearbeitet werden. Pro eingelesener Zeile Speicher bereitstellen! Würde ich in ein separates Modul auslagern, da vielfältig wiederverwendbar. Hier mal ein paar Prototypen nützlicher Funktionen dafür:

    /****************************************************************
 *  File  : TxtFile.h
 *  Descr.: Declares manager functions for text files
 ****************************************************************/
#ifndef TXTFILE_H
#define TXTFILE_H

#include "Defs.h" /* Defines BOOL, FALSE, TRUE, NULL and DECLARE_HANDLE() */

DECLARE_HANDLE(HTXTFILE);

void     TF_ClearAll(void);            /* Flushes and deletes all text files */
HTXTFILE TF_New(const char*);          /* Opens the specified file and reads all lines */
BOOL     TF_Flush(HTXTFILE);           /* Writes content of file back to disk if necessary */
void     TF_Delete(HTXTFILE);
int      TF_CountLines(HTXTFILE);
/* Following functions: Always 1-based index! */
char*    TF_ReadLine(HTXTFILE, int);   /* Retrieve line without NewLine char(s) */
BOOL     TF_WriteLine(HTXTFILE, int, const char*);
void     TF_DeleteLine(HTXTFILE, int);
void     TF_InsertLine(HTXTFILE, int); /* Pass zero to append new line at end of file */

#endif  /*TXTFILE_H*/

    Dein Code im Hauptprogramm benutzt das TxtFile-Modul dann so:

    #include "TxtFile.h"
//...
HTXTFILE hConfig = TF_New("config.xml");
if(hConfig)
{
    //...
    TF_Delete(hConfig);
}
else
    CantOpen();

    [ Dieser Beitrag wurde am 15.04.2003 um 11:44 Uhr von Krösus editiert. ]

    0
  • K

    Hier die wichtigsten Funktionen aus TxtFile.c:

    /****************************************************************
 *  File  : TxtFile.c
 *  Descr.: Implementiert Funktionen zur Behandlung von Text-Dateien
 *          mit Hilfe der TxtFile-Datenstruktur: Eine Text-Datei wird
 *          als Liste von Zeilen interpretiert
 ****************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "TxtFile.h"
#include "List.h" //Listen-Bearbeitung

static HLIST slAlleTFs = NULL; //Liste mit TxtFile*

static void LadeTF(HLIST, FILE*);
static void EntfNewLine(char*); //Entfernt den NewLine-Abschluss von einer Zeile

typedef struct _TxtFile
{
    char* szDateiName; //Dateiname
    HLIST lZeilen;     //Liste mit char*
    BOOL bDirty;       //Speichern noetig?
    int iRef;          //Um Datei mehrfach zu lesen
} TxtFile; //HTXTFILE wird stets auf TxtFile* gecastet

//TF_New()     : Liest uebergebene Datei und erzeugt neues Text-File-Handle
//HTXTFILE     : Handle der Datei
//_szDateiName : Dateiname
HTXTFILE TF_New(const char* _szDateiName)
{
    TxtFile* pDatei;
    FILE* pfInput;
    if(!slAlleTFs)
        slAlleTFs = LST_New();
    ITERATE_LIST(slAlleTFs, TxtFile*, pDatei)
        if(!stricmp(_szDateiName, pDatei->szDateiName))
        {
            pDatei->iRef++; //Datei schon geoeffnet!
            return (HTXTFILE) pDatei;
        }
    END_LIST
    pDatei = (TxtFile*) malloc(sizeof(TxtFile));
    if(!pDatei || !(pfInput = fopen(_szDateiName, "r")))
        return NULL;
    pDatei->szDateiName = strdup(_szDateiName);
    pDatei->lZeilen = LST_New();
    pDatei->bDirty = FALSE;
    pDatei->iRef = 1;
    LST_Append(slAlleTFs, pDatei);
    LadeTF(pDatei->lZeilen, pfInput);
    fclose(pfInput);
    return (HTXTFILE) pDatei;
}

//TF_ReadLine() : Liest eine Zeile einer Textdatei ohne den NewLine-Abschluss
//char*         : Gesuchte Zeile (Vorsicht: Direkter Zugriff!),
//                oder NULL wenn Zeilenindex ungueltig
//_hFile        : Handle der Textdatei
//_iIndex       : 1-basierter Zeilenindex
char* TF_ReadLine(HTXTFILE _hFile, int _iIndex)
{
    TxtFile* pDatei = (TxtFile*) _hFile;
    if(!LST_GoTo(pDatei->lZeilen, _iIndex))
        return NULL;
    return (char*) LST_Current(pDatei->lZeilen, NULL);
}

#define PUFFERGROESSE 0x7FFF

//LadeTF() : Laedt eine Textdatei
//_lZeilen : Liste, welche die zu lesenden Zeilen speichert
//_pfInput : Eingabedatei
void LadeTF(HLIST _lZeilen, FILE* _pfInput)
{
    char szPuffer[PUFFERGROESSE];
    while(fgets(szPuffer, PUFFERGROESSE - 1, _pfInput))
    {
        szPuffer[PUFFERGROESSE - 1] = '\0';
        EntfNewLine(szPuffer);
        LST_Append(_lZeilen, strdup(szPuffer));
    }
}

//etc.
    0
  • ?

    @Krösus

    Dein Code sieht nicht nach ANSI C aus.

    @flo

    Es kommt immer darauf an wie du dein Datei auslesen willst. Wenn du z.B jede Zeile lesen willst machst du das am bessten mit:

    fscanf(file,"%s",struct_xy.content);

    content darf aber kein zeiger sein, sondern z.B. content[255]; Am bessten eigenen sich dann Verkette Listen. Dies ist etwas komplizierter also such am bessten mit googe.de

    0
  • K

    Original erstellt von <FREAK>:
    Dein Code sieht nicht nach ANSI C aus.

    Inwiefern??? 😕
    Genau so macht man das aber, mein Lieber!

    0
  • D

    strdup und stricmp gehören nicht zu ISO-C, free fehlt, deinen Header hast Du nicht mitgepostet, _ gefolgt von Großbuchstaben darfst Du nicht verwenden, E gefolgt von Großbuchstaben auch nicht, wenn Du errno benutzt (das tust Du nicht). Blieben noch die tausende Typen, die Casts und die Notation. Noch was?

    0
  • K

    strdup und stricmp gehören nicht zu ISO-C
    Ehrlich? Wußte ich nicht. Lasse mich aber gerne belehren (Referenz?). Im Zweifelsfall kann man die Funktionen ja ganz leicht selbst schreiben.

    free fehlt
    Wo denn, bitteschön??? Objekte, die ich unter Verwendung von malloc() erzeuge, speichere ich, falls es jemandem entgangen sein sollte, in Listen. Werden diese gelöscht, so werden Funktionen aufgerufen, die ich unter

    //etc.

    zusammengefaßt hatte!

    deinen Header hast Du nicht mitgepostet
    Ich hatte geschrieben, daß in dem Header BOOL, FALSE, TRUE, NULL und DECLARE_HANDLE() definiert wird.
    Aber bitte, hier die Definitionen:

    #define BOOL int
#define FALSE 0
#define TRUE (!FALSE)
#define NULL ((void*) 0)
#define DECLARE_HANDLE(HandleName) typedef struct { int unused; } * HandleName

    alles jeweils mit #ifndef und #endif geklammert.
    List.h deklariert Funktionen für eine Liste, welche void-Pointer speichert, außerdem die beiden Makros ITERATE_LIST und END_LIST zum durchiterieren durch die Liste. Dachte, das wäre selbsterklärend.

    _ gefolgt von Großbuchstaben darfst Du nicht verwenden
    E gefolgt von Großbuchstaben auch nicht
    struct _TxtFile und END_LIST sollen illegal sein?!?! Mein Compiler hat's zwar ohne Warnung geschluckt, aber wenn dem so ist (Referenz?), dann muß man sich natürlich an diese schwachsinnige Regel halten. Ich lasse mich, wie gesagt, gern belehren.

    Blieben noch die tausende Typen
    Ja, die führte man ein, um Programme besser verstehen zu können. Bitte sag nicht, daß typedef und #define neuerdings auch illegal sind!

    die Casts
    Sehr witzig: HTXTFILE caste ich IMMER auf TxtFile* und umgekehrt, weil man genau damit die Trennung zwischen Deklaration und Implementation erreicht. Schon mal was von modularer Programmierung gehört?
    Und meine Liste speichert void-Pointer, damit sie unabhängig von den gespeicherten Objekten gehalten und somit wiederverwendet werden kann.
    Außerdem bezweifle ich stark, daß diese Casts illegal sind.

    die Notation
    ??? Meinst Du vielleicht die //-Kommentare? Wenn's der Compiler wirklich nicht schluckt, kann man die ja auch leicht ersetzen. Oder was ist denn sonst an der Notation auszusetzen?

    Noch was?
    Jawohl, und zwar soll man bei der Software-Erstellung folgendes berücksichtigen:
    Programme sollen
    - ihren Zweck erfüllen
    - sicher laufen
    - gut verständlich und wartbar sein
    - sowie durch Einbeziehung wiederverwendbarer Module schnell entwickelt werden!

    [ Dieser Beitrag wurde am 16.04.2003 um 08:24 Uhr von Krösus editiert. ]

    0
Anmelden zum Antworten