Immer noch probleme mit Speicherung von Listen

[smilingman]

Erst mal ein frohes neues Jahr euch allen...

hab mir endlich ma zeit genommen un hab mich an meine
Liste gesetzt...Aufgabe war es die einzelnen Elemente
meiner Liste vor beenden des Progs. zu sichern und
nach dem Start wieder zu laden...so weit so gut.

Wollt es ja mit fread und fwrite machen...hat aber nich
so funktioniert wie ich wollt, deshalb hab ich mich dann
für fprintf und fgets entschieden...

zuerst dacht ich es funktioniert doch es gibt immer wieder
Fehler:

- wenn ich mehr wie sieben Zeichen eingebe schreibt es
falsche Werte in meine Elemente...obwohl meine Arrays
10 Felder groß sind

- wenn man das Prog öfters startet und wieder beendet
schreibt es auch aufeinmal komische Werte in meine
Elemente

muss irgend ein Fehler beim einlesen sein...am Anfang
hat er immer das Leerzeichen mit eingelesen...das wollt
ich umgehen in dem ich immer vor das leerzeichen ne binäre
Null setze aber funktioiert auch nich richtig...

weiß jetzt net mehr weiter, hoffe ihr könnt mir da helfen

hier noch mal mein Quellcode
die Funktionen save() und einlesen() sind die beiden
neuen Funktionen

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <windows.h>

//Deklaration der Funktionen
//---------------------------------------------------------------------------
int menue();
void liste();

struct DATEN *einlesen(struct listenkopf *head);
struct DATEN *neudaten();
struct listenkopf *newlist();
struct listenelement *newelement();

void loading(int y);
void einhangen(struct listenkopf *head, struct listenelement *newelement);
void save(struct listenkopf *head);
void KillElement(struct listenkopf *head);
void Killlast(struct listenkopf *head);
void ausgabe(struct listenkopf *head);
int ElementCount(struct listenkopf *head);

int adddata (struct DATEN *neudaten, struct listenelement *newelement);
int anhangen(struct listenkopf *head , struct listenelement *newlist);

//Struktur listenkopf
//---------------------------------------------------------------------------
struct listenkopf

{
	struct listenelement *ersteselement;
	struct listenelement *letzteselement;
};

//Struktur listenelement
//---------------------------------------------------------------------------
struct listenelement

{
	struct DATEN *daten;
	struct listenelement *next;
};

//Struktur Daten
//---------------------------------------------------------------------------
struct DATEN

{
	char flugnr[10];
	char nation[10];
	char litersprit[10];
};

//Main-Funktion
//---------------------------------------------------------------------------
void main()

{

liste();

}

//Newlist-Funktion
//---------------------------------------------------------------------------
struct listenkopf *newlist()

{
	struct listenkopf *head;
	head=(listenkopf *)malloc(sizeof(struct listenkopf));

	if(head !=0)
		{
		head->ersteselement=NULL;
		head->letzteselement=NULL;
		return head;
		}

	return 0;
}

//Newelement-Funktion
//----------------------------------------------------------------------------
struct listenelement *newelement()

{
	struct listenelement *element;
	element=(struct listenelement *)malloc(sizeof(struct listenelement));

	if(element!=0)

		{
		element->next=NULL;
		element->daten=NULL;
		}

		return element;
}

//Neudaten-Funktion
//-----------------------------------------------------------------------------
struct DATEN *neudaten()

{
	int x;

	struct DATEN *neudaten;
	neudaten=(struct DATEN*)malloc(sizeof(struct DATEN));

	if(neudaten!=0)

		{

		fflush(stdin);

		//Eingabe Flugnummer
		//-----------------------------------------
		do
		{
			system("cls");
			printf("Daten eingeben\n\n");
			printf("Flugnummer eingeben: ");
			gets(neudaten->flugnr);
			x=strlen(neudaten->flugnr);
			if(x>=8)
			{
				system("cls");
				printf("Falsche Eingabe(max. 7 Zeichen)");
				Sleep(500);
			}
		}
		while(strlen(neudaten->flugnr)>=8);

		//Eingabe Nation
		//-----------------------------------------
		do
		{
			system("cls");
			printf("Daten eingeben\n\n");
			printf("Nation eingeben: ");
			gets(neudaten->nation);
			x=strlen(neudaten->nation);
			if(x>=8)
			{
				system("cls");
				printf("Falsche Eingabe(max. 7 Zeichen)");
				Sleep(500);
			}
		}
		while(strlen(neudaten->nation)>=8);

		//Eingabe Sprit
		//-----------------------------------------
		do
		{
			system("cls");
			printf("Daten eingeben\n\n");
			printf("Sprit in Liter eingeben: ");
			gets(neudaten->litersprit);
			x=strlen(neudaten->litersprit);
			if(x>=8)
			{
				system("cls");
				printf("Falsche Eingabe(max. 7 Zeichen)");
				Sleep(500);
			}
		}
		while(strlen(neudaten->litersprit)>=8);

		return neudaten;
		}

	return 0;
}

//Daten Anhängen-Funktion
//------------------------------------------------------------------------------
int adddata (struct DATEN *neudaten, struct listenelement *newelement)

{
		newelement->daten=neudaten;
		return 1;
}

//Anhängen-Funktion
//------------------------------------------------------------------------------
int anhangen(struct listenkopf *head , struct listenelement *newlist)

{
	if (head ->ersteselement==NULL)

		{
		head->ersteselement=newlist;
		}

	if (head->letzteselement !=0)

		{
		head->letzteselement->next=newlist;
		}

		head->letzteselement=newlist;

	return 1;
}

//Menue-Funktion
//-------------------------------------------------------------------------------
int menue()

{
	int y;
	char x[1];

	do
	{
		system("cls");

		printf("\n=======================\n");
		printf("= [1] Liste eingeben  =\n");
		printf("= [2] Liste einhangen =\n");
		printf("= [3] Liste auslesen  =\n");
		printf("= [4] Kill Element    =\n");
		printf("= [5] Beenden         =\n");
		printf("=======================\n\n");
		printf("=> ");

		gets(x);

		y=x[0]+x[1];

	}
	while(y<49 && y>35);

	return y;
}

//Listen-Funktion
//--------------------------------------------------------------------------------
void liste()

{
	int eingabe;
	struct listenkopf *head;
	struct listenelement *ptrElement;
	struct DATEN *dataptr;

	head=newlist();
	loading(1);
	einlesen(head);

	do
	{

		eingabe=menue();

		switch(eingabe)

		{

		case 49:
		system("cls");
		ptrElement=newelement();
		dataptr=neudaten();
		adddata(dataptr, ptrElement);  //cin >> scanf    -> cout << printf -> iostraem.h 
		anhangen(head , ptrElement);
		break;

		case 50:
		system("cls");
		ptrElement=newelement();
		dataptr=neudaten();
		adddata(dataptr, ptrElement);
		einhangen(head, ptrElement);
		break;

		case 51:
		ausgabe(head);
		break;

		case 52:
		KillElement(head);
		break;

		case 53:
		loading(0);
		save(head);
		exit(1);
		break;

		}

	}

	while(eingabe!=53);

}

//KillElement-Funktion
//--------------------------------------------------------------------------------
void KillElement(struct listenkopf *head)
{

	int i;		//hilfsvariable
	int j;		//eingabe
	int z;		//element anzahl

	struct listenelement *element;
	struct listenelement *element2;
	element=head->ersteselement;
	system("cls");

	if(element==NULL)
	{
		printf("Liste ist noch leer!!!");
		getch();	
	}
	else
	{
		z=ElementCount(head);
		printf("Welches Element soll entfernt werden?\n");
		printf("=> ");
		scanf("%i",&j);

		if(j<=z)

		{
			//Letztes Element löschen
			if(j==z)
			{

				if(j==1)
				{
					head->ersteselement=NULL;
					head->letzteselement=NULL;
				}
				else
				{
					for(i=2;i<z;i++)
					{
						element=element->next;
					}

					element->next=NULL;
					head->letzteselement=element;
				}

			}

			//Erstes Element löschen
			if(j==1)
			{
				if(j!=z)
				{
				head->ersteselement=element->next;
				element->next=NULL;
				element->daten=NULL;
				}
			}

			//Mittlere Elemente löschen
			if(j>1 && j!=z)
			{

				for(i=2;i<j;i++)
					{
						element=element->next;
					}
				for(i=1;i<j;i++)
					{
						element2=element->next;
					}

				element->next=element2->next;
				element2->next=NULL;
				element2->daten=NULL;
			}

		}
		else
		{
			printf("Es gibt nur %i Element(e)",z);
			getch();
		}

	}
}

//Einhängen-Funktion
//--------------------------------------------------------------------------------
void einhangen(struct listenkopf *head, struct listenelement *newelement)

{

	int i;
	int x;
	int z;

	struct listenelement *element;
	struct listenelement *element2;
	element=head->ersteselement;
	element2=head->ersteselement;

	system("cls");
	z=ElementCount(head);
	printf("An welcher stelle soll das Element\n");
	printf("Eingehangt werden?\n");
	printf("=> ");
	scanf("%i",&x);

	if(x<=z)
	{

		if(x==1)
		{
			newelement->next=element;
			head->ersteselement=newelement;
		}

		if(x>1)
		{
			for(i=1;i<x;i++)
			{
				element=element->next;
			}
			for(i=2;i<x;i++)
			{
				element2=element2->next;
			}

			newelement->next=element;
			element2->next=newelement;
		}
	}
	else
	{
		printf("Es gibt nur %i Element(e)",z);
		getch();
	}

}

//Ausgabe-Funktion
//--------------------------------------------------------------------------------

void ausgabe(struct listenkopf *head)

{
	int x=0;
	struct listenelement *hilfsptr;
	hilfsptr=head->ersteselement;

	if(hilfsptr ==0)
	{
		printf("Fehler!!! Liste ist noch leer");
		getch();
	}

	else
	{
	while(hilfsptr !=0)

		{
		system("cls");
		x++;
		printf("%i. Flugzeug",x);
		printf("\n\nFlugnr.: ");
		printf("%s",hilfsptr->daten->flugnr);
		printf("\nNation: ");
		printf("%s",hilfsptr->daten->nation);
		printf("\nSprit: ");
		printf("%s\n",hilfsptr->daten->litersprit);
		hilfsptr=hilfsptr->next;
		getch();
		}

	}
}

//ElementCount-Funktion
//--------------------------------------------------------------------------------
int ElementCount(struct listenkopf *head)

{
	int count;
	count=0;

	struct listenelement *element;
	element=head->ersteselement;

	while(element!=0)
	{
		element=element->next;
		count++;
	}

return count;
}

//Save-Funktion
//--------------------------------------------------------------------------------

void save(struct listenkopf *head)

{

	int x=1;

	FILE *daten;
	daten=fopen("daten.dat","w");

	struct listenelement *element;
	struct DATEN *dat;

	element=head->ersteselement;
	dat=element->daten;

	if(daten!=0)
	{

		do
		{
			dat=element->daten;
			fprintf(daten,"%s\n",dat->flugnr);
			fprintf(daten,"%s\n",dat->nation);
			fprintf(daten,"%s\n",dat->litersprit);
			element=element->next;
			x++;
		}
		while(element && dat !=0);

	}
	else
	{
		printf("Fehler beim Speichern");
		Sleep(1600);
	}

	printf("Daten gespeichert");
	Sleep(1600);

	fclose(daten);
}

//Einlesen-Funktion
//----------------------------------------------------------------------
struct DATEN *einlesen(struct listenkopf *head)

{
	int l;

	FILE *datei;
	datei=fopen("daten.dat","rb");

	struct listenelement *element;
	struct DATEN *dat;

	if(datei!=0)
	{

			do
			{
				dat=(struct DATEN*)malloc(sizeof(struct DATEN));

				if(dat!=0)
				{
					fgets(dat->flugnr,15,datei);
					l=strlen(dat->flugnr);
					dat->flugnr[l-1]='\0';

					fgets(dat->nation,15,datei);
					l=strlen(dat->nation);
					dat->nation[l-1]='\0';

					fgets(dat->litersprit,15,datei);
					l=strlen(dat->litersprit);
					dat->litersprit[l-1]='\0';

					element=newelement();
					adddata(dat,element);
					anhangen(head,element);
				}

			}
			while(!feof(datei));

		fclose(datei);
		Killlast(head);

	}
	else
	{
		printf("Keine Daten gefunden");
		Sleep(1600);
		return 0;
	}

	printf("Daten geladen");
	Sleep(1600);

	return 0;
}

//Killlast-Funktion
//-------------------------------------------------------------------------
void Killlast(struct listenkopf *head)

{

	int i;
	int j;
	j=ElementCount(head);

	struct listenelement *element;
	element=head->ersteselement;

	if(j==1)
	{
		head->ersteselement=NULL;
		head->letzteselement=NULL;
	}
	else
	{
		for(i=2;i<j;i++)
		{
			element=element->next;
		}

		element->next=NULL;
		head->letzteselement=element;

	}

}
//loadingbalken
//--------------------------------------------------------------------
void loading(int y)

{

int x;

system("cls");

if(y==1)
{
	printf("Daten werden geladen\n");
}
else
{
	printf("Daten werden gespeichert\n");
}

for(x=0;x<=30;x++)
	{
		Sleep(25);
		printf(".");	
	}

}

[leo aka qsch]

1. benutze, fread und fwrite das macht die Sache einfacher
2. bitte poste nur soviel code wie sinnvoll, sonst macht sich fast keiner die Mühe das alles durchzustöbern

implementiere zuerstmal die Funktion die zum Speichern der Liste zuständig ist
und poste dann den code dieser funktion
danach erst das lesen der daten

achja dir auch ein frohes neues jahr

[spjoe]

HI

Hier folgen ein paar sachen die mir aufgefallen sind:

int menu(){
..
char x[2] //nich char x[1] weil mindestens 3 char gespeichert werden bei gets() und sowieso ist hier eine buffer overflow gefahr --> verwende fgets()
.....
}
void save(struct listenkopf *head)
{
   ....
        while(element && dat !=0)
        {
         dat=element->daten;
         fwrite(dat,sizeof(DATEN),1,daten);
         element=element->next;
         x++; //?? element zähler der nicht gebraucht wird!!
        }
 ....
}
struct DATEN *einlesen(struct listenkopf *head)
{
.....
while(!feof(datei))
            {
                dat=(struct DATEN*)malloc(sizeof(struct DATEN));

				assert(dat);

				fread(dat,sizeof(DATEN),1,datei);
                element=newelement();
                adddata(dat,element);
                anhangen(head,element);
            }
........
}

mfg