verkette Liste - zuweisen von Zeiger

Hallo,
habe eine verkette Liste ..

folgende Zeiger habe ich global festgelegt:

struct RealTimeData *next = NULL;
struct RealTimeData *anfang=NULL;

struct RealTimeData {
	unsigned int Zeit;
	double PCA_R1[12];
	double PCA_R2[12];
	struct RealTimeData *next;
	};

in einer Funktion habe ich folgendes gemacht ..

struct RealTimeData *zeiger;
.
.
.
zeiger=anfang;

Leider kann ich den anfang nicht an zeiger übergeben .. ?!?!?
Er meckert zwar nicht und führt den Schritt aus, aber im zeiger ist nichts drin (Adresse 0x000000)!

Woran könnte das liegen???

CStoll

Du hast 'anfang' ja auch als NULL angelegt, d.h. der zeigt zu Programmbeginn auf 0x00000000. Vielleicht solltest du den Aufbau deiner Liste damit beginnen, daß du ein neues Element per new anlegst und anfang darauf umbiegst.

Das erste Element kann ich anlegen .. da stehen auch sinnvolle Daten drin .. beim zweiten Element muss ich an einen "work" zeiger zeiger den anfang zeiger übergeben, damit der weis wo es los geht! Genau diese Übergabe funktioniert nicht?!?! Habe folgnden Link als Anleitung verwendet:

http://www.pronix.de/pronix-827.html

Die beschriebene Funktion anhaengen() benötigt diesen Schritt! Habe die Stelle in FETT markiert!!

void anhaengen(char *n, char *v, int at, int am, int aj,
                int eint, int einm, int einj, long g) {
   /* Zeiger zum Zugriff auf die einzelnen Elemente
    * der Struktur*/
   struct angestellt *zeiger;

  /* Wir fragen ab, ob es schon ein Element in der Liste
   * gibt. Wir suchen das Element, auf das unser Zeiger
   *  *anfang zeigt. Falls *anfang immer noch auf NULL zeigt,
   *  bekommt *anfang die Adresse unseres 1. Elements und ist
   *  somit der Kopf (Anfang) unserer Liste  */
   if(anfang == NULL) {
      /* Wir reservieren Speicherplatz für unsere Struktur
       * für das erste Element der Liste*/
      if((anfang = (struct angestellt *)
       malloc(sizeof(struct angestellt))) == NULL) {
         fprintf(stderr, "Kein Speicherplatz vorhanden "
                         "für anfang\n");
         return;
      }
      strcpy(anfang->name, n);
      strcpy(anfang->vorname, v);
      anfang->alter.tag = at;
      anfang->alter.monat = am;
      anfang->alter.jahr = aj;
      anfang->eingest.tag = eint;
      anfang->eingest.monat = einm;
      anfang->eingest.jahr = einj;
      anfang->gehalt = g;
      /* Somit haben wir unseren Anfang der Liste. Von nun an
       * zeigt der Zeiger anfang immer auf das Element vor ihm.
       * Da dies aber jetzt das 1. Element der Liste war, zeigt
       * der Zeiger anfang auf den Zeiger next. next zeigt am
       * Ende immer wieder  NULL   */
      anfang->next=NULL;
   }
   /* Es scheint schon mindestens ein Element in der Liste
    * vorhanden zu sein, da der Anfang nicht == NULL ist.
    * Jetzt suchen wir so lange nach dem nächsten Element,
    * bis der *next-Zeiger auf NULL zeigt. Somit haben wir
    * das Ende der Liste gefunden und können einen neuen
    * Datensatz anhängen  */
   else {

      [u][i][b]zeiger=anfang; /* Wir zeigen auf das 1. Element */[/b][/i][/u]

while(zeiger->next != NULL)
         zeiger=zeiger->next;
      /* Wir reservieren einen Speicherplatz für das letzte
       * Element der Liste und hängen es an.   */
      if((zeiger->next =(struct angestellt *)
       malloc(sizeof(struct angestellt))) == NULL) {
          fprintf(stderr,"Kein Speicherplatz für das "
                         "letzte Element\n");
          return;
      }
      zeiger=zeiger->next; /* zeiger auf neuen Speicherplatz */
      strcpy(zeiger->name,n);
      strcpy(zeiger->vorname,v);
      zeiger->alter.tag=at;
      zeiger->alter.monat=am;
      zeiger->alter.jahr=aj;
      zeiger->eingest.tag=eint;
      zeiger->eingest.monat=einm;
      zeiger->eingest.jahr=einj;
      /* Wir terminieren wieder unsere Datenstruktur */
      zeiger->gehalt=g;
      zeiger->next=NULL;
   }
}