✔ txt tabelle auslesen

T

TimRK

Grünschnabel
Moien.
Ich benötige eine Funktion zum auslesen einer Tabelle in form einer txt datei.
Bisher konnte ich jedoch keine vernünftige Erklärung diesbezüglich finden.

Die Spalten sind hierbei vertikal angelegt
Wert A B und C
Von A soll der Durchschnitt aller Werte berechnet werden.
B wird nochmals unterteilt in 1 und 2 und zusammengezählt (wie viele 1 und wie viele 2)
C wird abhängig vom status B eingelesen und wieder der Durchschnitt berechnet.
Sprich man kommt auf insgesammt 5 Werte welche am Ende ausgegeben werden sollen.

Was ich vll sogar schon habe... glaube ich... (also die funktion zur ausgabe der ergebnisse... keine große leistung aber hey)

int main () {
printf("Durchschnittliches Geburtsjahr:", %A);
printf("Anzahl Männer:", %B);
printf("Anzahl Frauen:", %C);
printf("Durchschnittliche Körpergröße Männer:", %D);
printf("Durchschnittliche Körpergröße Frauen:", %E);
}

Oder irre ich mich? :(

Wie man sieht bin ich zurzeit noch blutiger anfänger und komme leider nicht wirklich voran.
Hat wer ein paar gute tipps welche befehle ich nutzen sollte/könnte und wofür?
Ich möchte keine fertige funktion (auch wenn das cool wäre) sondern nur ein paar anregungen
um mich vll eines tages von "total noob" zum "immerhin etwas könner" auf zu schwingen :confused:

Beste grüße und guten start in die woche euch
Tim


PS: kennt jemand eine idiotenfreundliche auflistung der befehle von C mit kurzer definition?
 
Hi

C oder C++?
Sind die Spalten in der Datei einfach mit Leerzeichen getrennt?

Dein Programmcode kompiliert nicht einmal...

Eine "idiotenfreundliche" Auflistung der Befehle kenn ich nicht, aber da du printf kennst zählst du schon einmal nicht dazu :) (nicht so wie jemand gerade vor Kurzem, der Excel-Formeln schreiben für Programmieren hielt) . zB. CppReference hat Beschreibungen aller Standard-Funktionen, hier die Übersicht der Kategorien: http://en.cppreference.com/w/ . Zu beachten ist halt, dass es auf so ziemlich allen Betriebssystemen noch deutlich mehr gibt, außer der Mindestanforderung, und beliebige Libraries die noch Sammlung vergrößern können (=unendlich)
 
Zuletzt bearbeitet:
XD sehr freundlich x) ja die spalten sind nur durch whitespace getrennt ^^
aber ja mir ist auch aufgefallen, dass bei dem oben geschriebenen z.B. return 0; fehlt etc
mir ist klar, dass ich einen "zeiger" setzen muss ... nur wie ist die frage ... und wie gibt man z.B. die anweisung, dass er die spalten horizontal auslesen soll.

PS: ernsthaft excel-Formeln?????? oO
 
Muss noch einmal fragen (ich weiß, ich bin lästig :)):
C oder C++?
Leerzeichen? ("Whitespace" beinhaltet auch Zeilenwechsel, Tabulatoren und so ca. 100 andere Sachen)

Und ja, Excel-Formeln. Dummheit kennt keine Grenzen :)
 
äh ja leerzeichen un ja C x) und zwischen lästig und hilfreich gibt es doch meines erachtens bedeutende unterschiede xD
 
Ok.

Zuerst einmal zu den printf´s oben, weil dich die % etwas zu verwirren scheinen:
Generell kann man einfach mit
Code: 
printf("hallo");
Text ausgeben.
Wenn man Variablen wie
Code: 
int i;float f;
hat, deren Werte eingesetzt werden sollen, sind zwei Dinge nötig:
a) Als weitere Parameter an printf übergeben
Code: 
printf("hallo", i, f);
Kein Prozentzeichen hier (noch).
b) print mitteilen, an welcher Stelle welcher Wert eingefügt wird, und was es ist (int, float...).
Um das so in den Text einzubetten gibt es bei printf (und scanf, und Varianten davon)
bestimmte Platzhalter, die alle mit % beginnen, zB. %d für ints und %f für floats.
Könnte dann zB. so ausschauen:
Code: 
int i = 1;
float f = 1.234;
printf("Hier ein int %d und ein float %f", i, f);
Ausgabe ist dann sowas wie: Hier ein int 1 und ein float 1.234
Der erste Platzhalter gilt eben für die erste Variable nach dem Text usw.
Die Platzhalter beziehen sich nur auf die genannten Funktionen (printf/scanf),
sie sind nicht irgendwie generell für die Variablentypen gültig.
Eine vollständige Liste findet man im Internet, wenn nötig.

So, zum Dateiteil:
Es gibt also pro Textzeile drei Werte, mit Leerzeichen getrennt, und aus denen soll was berechnet werden.
Du scheinst dir Sorgen zu machen, wie man die Datei zeilenweise statt spaltenweise verarbeitet,
weil es fürs Auge vielleicht wie drei Spalten ausschaut. Aber das ist gar kein Problem,
zeilenweise Verarbeitung ist die Norm (spaltenweise wäre schwieriger).
Ich vermute, Spalte 1 und 2 sind ints, und Spalte 3 floats (Kommazahlen)?

Zum Beginn wäre vllt. einmal nicht schlecht, die Berechnungen kurz zu vergessen
und das Programm so zu machen, dass es jede Zeile einliest und einfach wieder ausgibt.

Die Datei zum Auslesen vorbereiten ist nicht so schwer, wenn man ein paar Funktionen kennt.
Code: 
FILE *f; //Variable vom Typ FILE, statt int oder so

//dateiname.txt für "r"ead öffnen. Nähere Beschreibung zu fopen ggf. im Internet.
f = fopen("dateiname.txt", "r");

//wenn der "Wert" von f NULL ist hats nicht geklappt (zB. wenns die Datei nicht gibt)
if(f == NULL)
{
    printf("Konnte nicht geöffnet werden");
    return 0; //Programm beenden, statt weitermachen
}

printf("Datei offen"); //wenn man eine Bestätigung will...
//hier dann die Lesevorgänge aus der Datei

//zum Abschluss, Gegenteil von fopen:
fclose(f);

Versuch das einmal in einem Programm zu Laufen zu bringen, vorm Weitermachen

Zum Einlesen selber:
Es gibt eine ganze Reihe von möglichen Funktionen, die zB. bei jedem Aufruf einen Buchstaben bzw. Zeichen generell einlesen, pro Aufruf eine ganze Zeile in ein Array von Buchstaben speichern usw. Da du ja an den Zahlenwerten interessiert bist ist das alles zu umständlich. Vermutlich kennst du schon scanf, um was von der Tastatur einzulesen, mit Typ-Platzhaltern wie bei printf? Da gibts nämlich auch eine Variante fscanf, die als Datenquelle eine Datei hat. Sowas in der Art für eine Zeile:
Code: 
int spalte1;
int spalte2;
float spalte3;
FILE *f;

//...fopen usw.

fscanf(f, "%d %d %f", &spalte1, &spalte2, &spalte3);

//fclose usw.
Viel mehr als so ein fscanf ists für eine Zeile nicht.

Sowas kann man jetzt in einer Schleife anwenden, um alle Zeilen nacheinander auszulesen... mit einem Problem: Erkennen wann man bei der letzten Zeile vorbei ist. Da gibts auch wieder verschiedene Möglichkeiten, und wieder ist fscanf ziemlich angenehm: Es hat einen Returnwert, wie viel Variablen es erfolgreich eingelesen hat. Also, bei ordentlichen Zeilen wäre das hier 3 (weil drei Platzhalter und drei Variablen), beim nächsten Aufruf nach der letzten Zeile ist es nicht mehr 3.
(Gleichzeitig hat man so auch eine Kontrolle auf andere mögliche Probleme außer Dateiende)
Code: 
while(3 == fscanf(f, "%d %d %f", &spalte1, &spalte2, &spalte3))
{
    //tu noch was, zB. das Eingelesene mit printf am Bildschim ausgeben
}

So...wenn du bis hierher gekommen bist, ist nicht mehr viel zu tun.
Damit der Beitrag nicht zu groß wird hier einmal Ende;
wenn du soweit bist oder Probleme hast bitte wieder melden.
 
Zuletzt bearbeitet:
coooooole sache ... werd mich mal daran probieren... mal schauen ob ich das alles korrekt verstehe und hin bekomme^^
besten dank meister!
 
TimRK hat gesagt.:
PS: kennt jemand eine idiotenfreundliche auflistung der befehle von C mit kurzer definition?
Zum Vergrößern anklicken....
In C gibt es keine Befehle, sondern Funktionen. Und davon erst noch "abzählbar unendlich", wie es so schön heisst, also eine komplette Liste wirst du nie finden.

Für die einfache Datenverarbeitung, wie du sie machen willst, versuche ich mal, eine Liste zu erstellen. sheel hat schon einige davon verwendet.

Grundsätzlich gilt folgende Nomenklatur:

Als 1-Zeichen-Präfix:
  1. s-: Stringoperation (selten auch a für ANSI/ASCII)
  2. f-: Fileoperation
  3. m-: Arbeitsspeicher(=Memory)-Operationen
Als 3-Zeichen-Präfix:
  1. str-: Stringoperation. Achtung: Selten wird mit str auch "Stream" abgekürzt. (Beispiel: Visual Studio gibt die Fehlermeldung str==NULL aus, wenn eine Datei (=stream) nicht geöffnet werden konnte)
  2. mem-: Arbeitsspeicheroperationen.

Mittelteile (meist selbsterklärend)
  1. -open-: Etwas wird geöffnet. Meist muss dann analog 2. beachtet werden
  2. -close-: Etwas wird geschlossen (und freigegeben)
  3. -read-: Etwas lesen
  4. -write-: Etwas schreiben (auch Bytes, die du "nicht lesen kannst"
  5. -scan-: Etwas auslesen
  6. -print-: Etwas schreiben (nur Bytes, die du lesen kannst)
  7. -get-: Etwas "bekommen" (meist eine vereinfachte Leseoperation)
  8. -put-: Etwas "stellen" (meist eine vereinfachte Schreiboperation)
  9. -cpy-: Etwas kopieren (copy)
  10. -cat-: Zusammenfügen ((con-)catenation)
  11. -cmp-: Etwas vergleichen (compare)
  12. -mov- oder -move-: Etwas verschieben
  13. -alloc-: Speicherbereich anfragen (ist relativ spezialisiert)
  14. -free-: Eigentlich fällt mir nur gerade eine solche Funktion ein, passt aber schön ins POSIX-Muster.
  15. -to-: Konvertierung.
Suffixe:
  1. -c: Char (also 1 Byte)
  2. -s: C-String (ein bisschen kompliziert für den Beginn. Kurz zusammengefasst: Ein C-String sind viele chars aneinander und dann ein 0-Byte). Bitte nicht verwirren lassen.
  3. -f: Steht für "Formatted" und bedeutet, dass du wie bei sheel's printf-Beispiel einen Format-String, z.B. "bla %d %s etc" angeben musst.
  4. -f: Manchmal auch "float". Im Kontext macht es fast immer Sinn.

Erweiterte Suffixe:
  1. -_s: Beachte den Unterstrich. Ist von Microsoft erzwungen, falls du mit Visual Studio arbeiten willst. Steht für "Secure" und bedeutet, dass du Maximallängen angeben (oder, bei Dateien, eine zusätzliche Errormessage abfrangen) musst, um Overflows vorzubeugen. Auch hier: Lass dich nicht verwirren. Du wirst das wahrscheinlich nie brauchen, wenn du auf Linux programmierst oder unter Windows die Fehlermeldungen deaktivierst.

Sehr selten (brauchst du nur, wenn du wirklich genau diese Sachen tun willst):
mbs (Multi-Byte-String (ergo Unicode u.ä.)), sz (zero-terminated string, C-String), wcs (Wide-Char-String).


Da ich sicher etwas vergessen habe, sind Ergänzungen willkommen.

Nun zu den Familien.

Die printf-Familie:
  1. printf(const char* format, ...): Gibt einen formatierten String auf die Konsole aus. Äquivalent zu fprintf(stdout, const char* format, ...)
  2. fprintf(FILE* target, const char* format, ...): Schreibt einen formatierten String in eine Datei
  3. sprintf(char* target, const char* format, ...): Schreibt einen formatierten String in einen anderen String
Die put-Familie:
  1. puts(const char* string): Schreibt einen String auf die Konsole und beginnt eine neue Zeile. Äquivalent zu printf("%s\n", string);
  2. fputs(FILE* f, const char* string): Schreibt einen String in eine Datei und beginnt eine neue Zeile
  3. putc(const char c): Schreibt ein einzelnes Zeichen auf die Konsole. Äquivalent zu printf("%c", c);
  4. fputc(FILE* f, const char c): Schreibt ein einzelnes Zeichen in eine Datei.
Die scanf-Familie:
  1. scanf(const char* format, ...): Liest Daten im gegebenen Format ein. Achtung: scanf ist ein Kapitel für sich selbst und lies immer nach, was das Format genau heisst! Äquivalent zu fscanf(stdin, const char* format, ...)
  2. fscanf(FILE* f, const char* format, ...): Liest Daten im gegebenen Format aus einer Datei.
  3. sscanf(const char* source, const char* format, ...): Liest Daten im gegebenen Format aus einem String
Die to-Familie:
  1. int atoi(const char* str): (Lies a-to-i) ASCII to Integer: Konvertiert String zu Zahl, also z.B. atoi("123") == 123
  2. ... (selbsterklärend)

Da du nun sehr viel mit Dateien arbeiten willst:

Dateien
  1. fopen(const char* path, const char* mode): Öffne die Datei unter dem Pfad 'path' im Modus 'mode'. Modi: "r": Nur lesen, "w": Nur schreiben. etc. Genaueres HIER
  2. fgets(char* target, size_t maxcount, FILE* source): Zeilenweises Auslesen. Liest bis zu einer neuen Zeile oder bis maxcount Zeichen gelesen wurden.
  3. fread(FILE* f, size_t size, size_t count, char* target): Byteweises Auslesen. Wird benutzt, um gesamte Dateien oder Binärdateien einzulesen.
  4. fscanf(FILE* f, const char* format, ...): Siehe sheels Ausführungen
  5. fputs(const char* source, FILE* target): Schreibt eine Zeile in die Datei (Gegenteil von fgets)
  6. fwrite(FILE* f, size_t size, size_t count, char* source): Byteweises Schreiben. Gegenteil von fread
  7. fprintf(FILE* f, const char* format, ...): Formatiertes Schreiben (nur ASCII): Gegenteil von fscanf
  8. fclose(FILE* f): Schliessen der Datei. Gegenteil von fopen und absolut wichtig! NICHT VERGESSEN! (Fliegt dir das Haus um die Ohren? Nein. Aber was passieren kann, ist, dass ein anderes Programm auf eine Datei zugreifen will und das nicht mehr kann, weil dein Programm sich die Datei offenhält, ohne sie zu brauchen. Daher: Sei kein Messi. Schmeiss weg, was du nicht mehr brauchst :)

Diese Liste ist keinesfalls komplett. Aber ich hoffe, sie gibt dir einen Überblick.

Gruss
cwriter
 
Nur zwei kleine Anmerkungen noch dazu:

Sachen wie fclose zu vergessen kann auch dazu führen, dass ein geschriebener
Dateiinhalt doch nicht gespeichert wird usw.usw. Also nicht vergessen.

Und noch einmal betont, diese Liste ist wirklich keine komplette Funktionsliste.
Allein die für C vorgeschriebenen Funktionen dürfte eher in Hunderten gemessen werden (genaue Zahl nicht gefunden), und mit Einbeziehung der Betriebssystem-eigenen Sachen gehts in die Tausende. zB. für Windows sind hier https://msdn.microsoft.com/en-us/library/windows/apps/dn424765.aspx mehr als 3100 Funktionen aufgelistet, und da fehlt vermutlich noch einiges (mindestens das ganze Kernelzeug). Linux und andere sind vergleichbar.
...und da jeder neue Libs schreiben und verteilen kann, die neue Funktionen anbieten,
wirds eben unendlich (bijektiv zu N :))
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück