Variable in Funktion vergrößern

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;
}