4. Probleme mit Speicherung von Listen

Probleme mit Speicherung von Listen

  • S

    Hallo erst mal...

    soll für die die Schule eine verkettete Liste schreiben.
    War garnich so schwer, doch jetzt soll ich die
    Daten meiner einzelnen Elemente abspeichern und wieder laden.

    Wollte des eigentlich mit fread und fwrite machen.
    Weiß aber nicht wie ich des am besten in meine vorhandene Liste
    integrieren soll? Vielleicht könnt ihr mir da ja weiter helfen.

    Ich bräucht ne Funktion save():Die alle Daten der Elemente,
    in eine Datei schreibt, bevor man das prog schliesst

    un ne Funktion load():Die die Daten nach starten des Progs wieder
    in die einzelnen Elemente lädt.

    Würde mich über eure Hilfe freuen!!!

    So sieht meine Liste im Moment aus:

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

//Deklaration der Funktionen
//---------------------------------------------------------------------------
int menue();
void liste();
void einhangen(struct listenkopf *head, struct listenelement *newelement);
struct DATEN *neudaten();
struct listenkopf *newlist();
struct listenelement *newelement();
void KillElement(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];
	int litersprit;
};

//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()

{

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

	if(neudaten!=0)

		{
		printf("Daten eingeben\n\n");
		fflush(stdin);
		printf("Flugnummer eingeben: ");
		gets(neudaten->flugnr);
		printf("\nNation eingeben: ");
		gets(neudaten->nation);
		printf("\nSprit in Liter eingeben: ");
		scanf("%i",&neudaten->litersprit);
		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 x;

	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("=> ");

	scanf("%i",&x);

	return x;
}

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

{
	int eingabe;
	struct listenkopf *head;
	struct listenelement *ptrElement;
	struct DATEN *dataptr;
	head=newlist(); 

	do
	{

	eingabe=menue();

		switch(eingabe)

		{

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

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

		case 3:
		ausgabe(head);
		break;

		case 4:
		KillElement(head);
		break;

		case 5:
		exit(1);
		break;

		default:
		printf("Kenn ich...aber mach ich net\n");

		}
	}

	while(eingabe<=4);

}

//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\nNation: ");
		printf("%s",hilfsptr->daten->nation);
		printf("\nFlugnr.: ");
		printf("%s",hilfsptr->daten->flugnr);
		printf("\nSprit: ");
		printf("%i\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;
}
    0
  • *

    Hi
    Wo ist das Problem? Du musst nur die ganze Liste durchlaufen und immer das Datenelement schreiben... 🙄

    Weiß aber nicht wie ich des am besten in meine vorhandene Liste
    integrieren soll?

    Das verstehe ich nicht so ganz. Was meinst du mit integrieren? In C++ könntest du Methoden verwenden, aber in C gibts das nicht... und mach mal void main weg. Warum bindest du die windows.h Bibliothek ein? Die könnte eigentlich auch raus. Ach ja: Wenn du so postest, erweckt das für mich den Eindruck, ich soll deine Hausaufgaben lösen, was ich natürlich nicht tun werde, da es _deine_ Hausaufgaben sind. 😋

    0
  • L

    smilingman das was du tun musst:
    schreib dir eine einfache save funktion die ruft du dann auf wenn die komplette liste in einer datei gespeichert werden soll

    die sollte intern so aufgebaut sein

    int save ()
{
    Waehrend ( lisenende bzw listenende nicht erreicht )
    {
        schreibe
        naechstes listenelement // bzw vorheriges
    }

    gib ergebniss zurueck zb die anzahl der geschriebenen byte
}

    die funktion könnte man mit ein paar kleinen tricks natürlich noch etwas einfacher und objektorientierter schreiben, aber so sieht halt mal der grundaufbau aus

    das laden funktioniert im prinzip fast genauso

    soweit alles klar?

    0
  • A

    @smilingman
    Versuch doch erstmal selber es zu machen. Falls du dann Probleme hast, helfen wir dir gerne. Aber eine Komplettlösung wirst du von uns nicht bekommen. Schließlich sollst du was lernen.

    Wie fread() und fwrite() funktionieren bzw. wie Dateihandling überhaupt funktioniert weißt du, oder??

    0
  • S

    Habt ja recht...eigentlich müsst ich des auch alleine hinkriegen.
    wollt mirs halt einfach machen...

    Also...vielen Dank für eure schnelle Antwort und ich meld
    mich falls ich irgendwo nich weiter komm...

    gruzzz

    0
Anmelden zum Antworten