Variable in Funktion vergrößern

worst_case

Hi,

mein Programm manipuliert zyklisch eine Textdatei. Dazu lese ich zuerst die Datei aus und schreibe die daten (Zeilen) in eine Variable die ich mit malloc anlege. Meine Funktionen löschen Zeilen heraus oder fügen neue Zeilen an den Anfang der Variable. Die Zeilen sind unterschiedlich lange.
Wie ändere ich hier den Speicher der Variable.
Ich dachte mir ich übergebe die Adresse des Speichers an die Funktion.

Sollte eine Zeile gelöscht werden kopiere ich die nachfolgenden Zeilen in der Variable nach vorne.
Wenn eine Zeile hinzukommen sollte ändere ich die übergebende Adresse (Variable vergrößern) in der Funktion mit realloc schreibe die neue Zeile hinein und gebe die neue Adresse als Rückgabewert zurück.

Zum Schluss wird die Variable (mit den Zeilen) wieder in die Datei geschrieben.

Da ich sowas noch nicht gemacht habe wollte ich nur Fragen ob ich das so realisieren kann, oder ob es eine einfachere oder bessere Möglichkeit für mein Problem gibt ?

Danke
worst_case

[ Dieser Beitrag wurde am 25.04.2003 um 20:29 Uhr von worst_case editiert. ]

DrGreenthumb

Wenn ich dich richtig verstanden habe, willst du eine Datei Zeilenweise im Speicher halten und hier und da Zeilen einfügen/löschen?

Dann nimm für die Zeilen eine verkettete Liste.

worst_case

Hallo,

verkettete Liste ?
Die Zeilen können unterschiedlich lang sein, jedoch nicht über eine bestimmte länge (z.B. 80 Zeichen)

worst_case

[ Dieser Beitrag wurde am 27.04.2003 um 11:28 Uhr von worst_case editiert. ]

Shade Of Mine

dann könntest du auch ein char* array nehmen...

DrGreenthumb

Original erstellt von worst_case:
verkettete Liste ?

Heißt das, du weißt nicht was das ist, oder du fragst nach wieso du sie verwenden sollst?

Das die Zeilen alle eine fixe Länge haben ist ja egal, bzw. noch praktischer weil du sie nicht mit malloc() anlegen musst.

worst_case

Hi,

zu Shade : ich wollte eigentlich ein char Array verweden.

zu DrGreenthump : ich habe keine Ahnung was verkettete Listen sind, sorry.

worst_case

DrGreenthumb

Original erstellt von worst_case:
**zu DrGreenthump : ich habe keine Ahnung was verkettete Listen sind, sorry.
**

Dann würde ich mich damit auf jeden Fall mal beschäftigen.
Eine Erklärung meinerseits würde sich vermutlich nicht lohnen. Da findest du im Internet bestimmt mehr Informationen.

Shade Of Mine

ein char array wäre extrem lahm!

nimm ein char* array wenn du es wirklich schnell willst und nimm ne verkettete liste wenns gut sein soll.

ich dachte du meinst mit der frage ob du wirklich eine verwenden sollst, sorry - fehler meinerseits.

ich wäre auf für ne verkettete, aber einfach verkettet reicht IMHO.

zum googlen:
linked list heißts auf englisch

Flow_cplus

Verkette Listen sin eigenttlcih mit das flexibelste, was so dynamsiche Speicherverwaltung zu bieten hat.
Nur finde ich, das sie sich viel schöner implementieren lassen, wenn man die Objetorientierung C++ zur Verfügung hat. Den Dort kann man die etwas kompizierten Vorgänge in der Listenverwaltung ganz gut verpacken.

Tutorials gibst zu dem Thema viel.

Grüße Flow

Dill

moin,

verkettete listen sind ne klasse sache. hab grad mit C angefangen und allein die theoretische beschäftigung mit verk. listen als selbstzweck hat mich viel kapieren lasen was C so sein soll ...
ausserdem sind diese datenstrukturen einfach subba flexibel und schnell (oder?)

ich kann dir folgendes tutorial nur allerwärmstens empfehlen:
www.pronix.de -> C-programmierung -> standard-C

direkt zu den listen:
http://www.pronix.de/C/standard_C/c_programmierung_22.shtml

[ Dieser Beitrag wurde am 29.04.2003 um 11:57 Uhr von Dill editiert. ]

Shade Of Mine

Original erstellt von Flow_cplus:
**Nur finde ich, das sie sich viel schöner implementieren lassen, wenn man die Objetorientierung C++ zur Verfügung hat. Den Dort kann man die etwas kompizierten Vorgänge in der Listenverwaltung ganz gut verpacken.
**

versteh ich nicht...

ist es nicht egal ob man
list.push_back(foo);
oder
push_back(list, foo);
macht?

hier spieglt sich IMHO nicht der 'große Vorteil' von OOP wider.

Bashar

Ob

list.push_back(foo);

oder

push_back(list, foo);

ist eine Frage der Syntax, keine von OOP oder nicht OOP. Die zweite Form findet man bspw. genau so in Ada95, und äquivalent in CLOS: (push-back list foo).

worst_case

Abend,

bin gerade dabei eine einfach-verkettete Liste zu schreiben.......big problems
Leider habe ich auch die Beispiele im Internet oder in meinen Büchern nicht wirklich verstanden.
Hier mal mein Code:
Mit diesem snippets will ich einfach (nur Test, um das System zu verstehen) eine verkettete Liste mit einem Text füllen. Das Programm ist...klar eine Endlosschleife, also nur zum Test mit dem Debugger !!

/* Global variable */
typedef struct element
{
struct element *next;
char zeile[255];
} stoerung;

typedef stoerung *zeileptr;

stoerung listen_kopf;  /* ist der Listenkopf */

int main(int argc, char *argv[])
{
listen_kopf.next = NULL;

   for (;;)
        {
        i = list_add ("Dies ist ein Test");
        sleep (zycluszeit);
        }

  return EXIT_SUCCESS;
}
/*############################################################################*/
int list_add(char neue_zeile[255])
{
zeileptr ptr1hilf;
zeileptr ptr2hilf;

/* schreibe die Startadresse aus dem listen-Kopf auf den Zeiger */
     ptr1hilf->next = listen_kopf.next;

/* wenn kein Element vorhanden ist dann schreibe erste Adresse in den listenkopf */
       if (ptr1hilf->next == NULL)
          {
           ptr1hilf = (zeileptr) malloc (sizeof(stoerung));
           ptr1hilf->next = NULL;
           strcpy (ptr1hilf->zeile , neue_zeile);
           listen_kopf.next = ptr1hilf;
           return 0;
           }

/* suche ab 1. Knoten bis letzter erreicht wird */
   while (ptr1hilf->next != NULL)
         {
          ptr1hilf = ptr1hilf->next;
         }

/* wenn letztes gefunden dann füge neues EIN */

         ptr2hilf = (zeileptr) malloc (sizeof(stoerung));
         ptr2hilf->next = NULL;
         strcpy (ptr2hilf->zeile , neue_zeile);
         ptr1hilf->next = ptr2hilf;

return 0;
}