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

Nachdem das erst Element angelegt wird (funktioniert prima) wird an die folgende Position das nächste Element angehängt (else)! Der erste Schritt unter else :

zeiger = anfang;

sollte der

struct RealTimeData *anfang = NULL;

an

struct RealTimeData *zeiger = NULL;

übergeben werden! Dabei erhalte ich jedoch immer eine Access Violation!

void anhaengen(unsigned int Zeit, double *PCA1, double *PCA2) {

	int i;	
   /* Zeiger zum Zugriff auf die einzelnen Elemente der Struktur*/
	struct RealTimeData *zeiger = NULL;

  /* 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 RealTimeData *)malloc(sizeof(struct RealTimeData))) == NULL) {
       fprintf(stderr, "Kein Speicherplatz vorhanden für anfang\n");
       return;
      }

	  anfang->Zeit = Zeit;
	  for (i=0;i<10;i++){
		anfang->PCA_R1[i] = PCA1[i];
		anfang->PCA_R2[i] = PCA2[i];
	  }	  

      /* 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 {
	 [b]zeiger = anfang;[/b]
      //memcpy(&zeiger,&anfang,sizeof(RealTimeData));

	  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 RealTimeData *)malloc(sizeof(struct RealTimeData))) == NULL) {
          fprintf(stderr,"Kein Speicherplatz für das letzte Element\n");
          return;
      }

	  zeiger=zeiger->next; /* zeiger auf neuen Speicherplatz */      

	  zeiger->Zeit = Zeit ;
	  for (i=0;i<10;i++){
		zeiger->PCA_R1[i] = PCA1[i];
		zeiger->PCA_R2[i] = PCA2[i];
	  }
      /* Wir terminieren wieder unsere Datenstruktur */
      zeiger->next=NULL;
   }
}

Habe schon versucht die Elemente einzeln zu kopieren .. liefert das gleiche
Ergebniss. Ebenfalls erfolglos war das kopieren mit

memcpy(&zeiger,&anfang,sizeof(RealTimeData));

Hoffe jemand kann mir da weiterhelfen!!!

Gruß
Michael

Verschiebst du möglicherweise in einer anderen Funktion den anfang-Zeiger?

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

Der anfang Zeiger wird nur hier verschoben ..

bei mir funktioniert die Routine anhaengen. Dein Fehler muß woanders liegen.

Übrigens, in anhaengen werden nur 10 Elemente kopiert, nicht 12.

cu, Bernd

#include <stdio.h>
#include <malloc.h>

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

struct RealTimeData *anfang = NULL;
struct RealTimeData *zeiger = NULL;

void anhaengen(unsigned int Zeit, double *PCA1, double *PCA2);

int main(void)
{
	double d1[10] = { 0.1,1,2,3,4,5,6,7,8,9 };
	double d2[10] = { 0.2,1,2,3,4,5,6,7,8,9 };
	double d3[10] = { 0.3,1,2,3,4,5,6,7,8,9 };

	anhaengen( 0, d1, d2 );
	anhaengen( 1, d2, d3 );
	anhaengen( 2, d3, d1 );

	for ( zeiger = anfang; zeiger != NULL; zeiger = zeiger->next )
		printf( "%d:%g %g\n", zeiger->Zeit, zeiger->PCA_R1[0], zeiger->PCA_R2[0] );
	getchar();
	return 0;
}

void anhaengen(unsigned int Zeit, double *PCA1, double *PCA2) {
// ...
}

die habe ich von Deinem 1. Beitrag kopiert und NICHTS daran geändert.

cu, Bernd

Gruß
daMike