4. .dat Datei auslesen

.dat Datei auslesen

  • Y

    Moinmoin,

    Ich arbeite gerade an einem Programm, dass im Endeffekt in einer Datenbank Daten sortieren soll. Ich bin mit C noch nicht so warm, habe mir da inzwischen bisschen Grundlagen erarbeitet und noch eine gewisse Grundlage aus der C++ Vorlesung, aber alles nur so halbgar. 😉

    Zum Problem:
    Das Hauptprogramm an und für sich funktioniert schon so, wie es soll (zumindest glaube ich das ^^) - ich brauche noch ein paar Daten von dem Nutzer des Programms (Geometrieinformationen). Es ist bei ähnlichen Programmen üblich das ganze über .dat dateien einzulesen, also eine Datei in Linux die mit gedit editierbar ist.

    Bisher brauchte ich recht wenig Input, ich hatte es dann einfach mit fscanf und einer Schleife gemacht, eine Laufvariable mitgezählt und dann den 5, 10 etc. Wert einfach separat abgelegt (gepfuscht, ich weiß, aber es funktionierte ;)). Kann den Quelltext dazu nochmal gerne posten, aber ich glaube er ist eh nicht zielführend.

    Jetzt habe ich 2 Probleme – zum einen wird meine Datei und was ich einlesen möchte immer größer, zum anderen habe ich einen „variablen“ Anteil.

    Mein erster Gedanke zu dem Thema war gewesen direkt mit strukturierten Dateien zu arbeiten (vermutlich naheliegend), aber da habe ich es irgendwie nicht geschaft, dass ich die in einem mit gedit bearbeitbaren Format ausgegeben bekomme. Zumal ich dem letztendlichen Nutzer ja auch noch ein „blanko“ zur Verfügung stellen muss, wenn er keines hat, wäre das aber natürlich schön wenn das ginge.

    Ich bin gerade ein bissel ratlos und hab mich auch schon ein bischen durch mein c-Buch und hier durchs Forum gestöbert und wäre dankbar wenn mir jemand den Schubs in die richtige Richtung geben könnte (wie gesagt – ich bin nur armer Maschinenbauer und kein Informatiker, also sprecht bitte langsam ;)).

    Die .dat-Datei die ich im Endeffekt auslesen möchte sähe ungefähr so aus:

    total number of planes: [b]2[/b]	 
number of plane case one: [b]0[/b]	 
number of plane case two: [b]0[/b] 
number of plane case three: [b]2[/b]  	 
primary data filename: [b]test.grd[/b]

geometric information case three (1-3 normal unit vector (x,y,z), 4-6 centre point of plane (x,y,z), 7 site_one, 8 site_two): 

x: [b]0[/b]	y: [b]0[/b]   	z: [b]-1[/b]	x: [b]0[/b]	y: [b]0[/b]	z: [b]0[/b]	s_1: [b]12 [/b]	s_2: [b]5[/b] 		
normal_marker: 	[b]1 2 3 	[/b]
mirror_marker: 	[b]4 5 6[/b]

x: [b]1[/b]	y: [b]0[/b]   	z: [b]0[/b]	x: [b]0[/b]	y: [b]0[/b]	z: [b]0[/b]	s_1: [b]5[/b] 	s_2: [b]2 [/b]		
normal_marker: 	[b]7 8[/b]
mirror_marker: 	[b]9 10[/b]

    Die Werte die ich auslesen will und die vom Benutzer zu verändern sind, sind fett makiert. Für jede der case three Ebenen ist also so ein Block anzulegen mit den Geometrieinformationen und den „markern“. Die Marker sind der variable Anteil, da können zwischen 1 und theoretisch unendlich vorhanden sein (praktisch vermutlich 5-6), bei den Ebenen im Normalfall so 1 bis theoretisch unendlich, praktisch wohl nicht mehr als 10, vielleicht mal in Ausnahmefällen 20. Ich weiß hier in beiden Fällen auch erst während des Auslesens der Datei, wie viele Ebenen und wie viele Marker pro Ebene ich habe.

    Wenn du bis hier gelesen hast schonmal danke, ich hoffe mal es ist halbwegs ersichtlich geworden wo mein Problem ist und ich hoffe man kann mich auf irgendein Tutorial oder ähnliches Verweisen.

    0
  • Mod

    Muss es C sein? Das wäre in C++ so einfach...

    Naja, wenn es C sein muss, dann musst du erst einmal eine Menge lernen, da dir anscheinend eine Menge fehlt, vor allem dynamische Speicherverwaltung. Und dann musst du eine dynamische Datenstruktur programmieren, das was in C++ z.B. vector oder list sind (ich gehe mal davon aus, dass du diese kennst, wenn du früher mal C++ gemacht hast). Was genau, hängt davon ab, wie du später auf die Daten zugreifen möchtest, deine jetzige Beschreibung klingt nach vector. Du musst natürlich nicht alles nachmachen und es braucht noch nicht einmal objektorientiert zu sein, falls du weiterhin ein bisschen "pfuschen" möchtest.

    Ein prozeduraler Ansatz wäre, einer Lesefunktion nach und nach größere Arrays zum Beschreiben zu übergeben und diese meldet, ob der Platz reichte oder nicht. Ein objektorientierter Ansatz wäre, der Lesefunktion ein Vectordatenstruct zu übergeben und diese nutzt spezielle Vectordatenstruct"member"funktionen, um dieses zu füllen. In beiden Fällen sollte jedoch die Verantwortung für das dynamische Feld/Struct beim Aufrufer der Lesefunktion verbleiben, dieser legt es an und wenn er es nicht mehr braucht, gibt er es frei bzw. ruft den "Destruktor" auf.

    0

  • Wo ist das Problem?
    Deklariere dir eine passende struct mit Typkennzeichen deiner (3?) Typen,
    dann Top-Down:

    1x Lesefunktion für den Header
    1x Lesefunktion (parametrisierbar) für eine Menge von Datensätzen eines Typs
    1x calloc für dynamischen Speicher für deine gelesenen Datensätze (Anzahl liefert deine Header-Fkt.)

    0
  • Y

    Deklariere dir eine passende struct mit Typkennzeichen deiner (3?) Typen,

    Das Problem (zumindest das was ich bisher hatte) ist doch, dass ich mit c die Struktur als Binären Datensatz in der Datei speichern würden. Es geht ja darum das ich eine Datei habe die ich manuell per Editor verändern kann um sie dann als "Parameterliste" beim Aufruf mit zu übergeben. Wenn es doch geht wäre ich dafür natürlich sehr empfänglich ^^

    Muss es C sein? Das wäre in C++ so einfach...

    leider 😕 hatte ich an 1,2 anderen Stellen schon etwas geflucht...

    Ein prozeduraler Ansatz wäre, einer Lesefunktion nach und nach größere Arrays zum Beschreiben zu übergeben und diese meldet, ob der Platz reichte oder nicht.

    So ähnlich hatte ich auch angefangen (ich postes gleich doch mal ^^), indem ich einfach ein viel zu großes Array übergeben hatte und dann danach in eine passende Größe gespeichert hatte.

    int main(int argc, char *argv[])
{
char grd_datname[50];
char scan_char[5];
int parameter[]={1,1,1,1};
int i=0;
int p=0;
int h=0;
int x=0;
int m=0;
int stop=100;

int *mallpointer = (int *) malloc (8000 * sizeof(int));
FILE* param;
param = fopen(argv[1], "r");

if (!param)
{
	puts("parameter file error\n");
	exit(0);
}

do
{	
	fscanf(param,"%i", &scan_i);
	fscanf(param,"%s", scan_char);
	if (x==5) parameter[0]=scan_i;
	if (x==11)parameter[1]=scan_i;
	if (x==17)parameter[2]=scan_i;
	if (x==23)
	{
		parameter[3]=scan_i;
		stop=scan_i*8;
	}
	if (x==21)fscanf(param,"%s", grd_datname);
	if (x>41) 
	{
		mallpointer[p]=scan_i;
		p++;	
	}
	x++;
	}
while(p<stop);
fclose(param);

/***********************************************
Ende Parameter-Input
***********************************************/
	int anzahl_planes = parameter[3];
	int geoinfomatrix[anzahl_planes][8];
	for(i=0; i<anzahl_planes; i++)
	{
		for(m=0; m<8; m++)
		{
			geoinfomatrix[i][m]=mallpointer[h];
			h++;	
		}		
	}
free(mallpointer);
}

    Wie gesagt, das hatte soweit ja auch funktioniert, auch wenns hässlich ist. Jetzt zum einen kann ich ja, wenn ich irgendwann 30,40 Zeilen habe nicht mehr "Abzählen" in meiner Datei und zum anderen kamen dann die "Marker" dazu - die ja eine Variable Anzahl an Daten in einer Zeile haben...

    Die überlegung war jetzt über z.B. fgets Zeilenweise auszulesen und dann z.B. Zeile 1 die ersten 3 Strings abzuschneiden... aber wie kann ich sowas dann vernünftig zerlegen und wie kann ich das vernünftig zerlegen, dass ich mir zwischen 1 und... xxx markern in einer Zeile einlese dann? Oder ist es doch irgendwie anders schöner/besser?

    0
  • G

    Machs doch erstmal sowas:
    1.lies bis zum nächsten : alles in einen Puffer sollte in einer zeile kein : vorkommen ignorier sie
    2.stelle fest welchen typ diese option hat und lies dann dementspechend die Parameter ein
    3.packe alles in eine Sruktur

    0

  • Ynnead schrieb:

    Wie gesagt, das hatte soweit ja auch funktioniert, auch wenns hässlich ist.

    Tja das ist das Problem aller Anfänger (und pfuschenden Fachbuchautoren): "mein" Programm "funktioniert" doch, warum soll ich mich dann auf strukturiertes Design einlassen?
    Eben genau u.a. deswegen, weil bei strukturierter Vorgehensweise nicht nur der Lerneffekt höher ist, sich Arbeitsweisen für folgende Aufgaben ableiten/wiederverwenden lassen,... sondern sich Anpassungen/Erweiterungen am eigenen (Lern)Programm SEHR VIEL EINFACHER durchführen lassen, wie man an dir und deinen Gehversuchen sieht.

    0
Anmelden zum Antworten