Datei auslesen..

Hi,
ich komm irgendwie nicht weiter ^^'
Das ist das erste mal, dass ich fopen benutze, und es wird nur der erste Buchstabe eingelesen.. darum erbitte ich eure Hilfe, danke

char c;
	int a = 0;
	char str[256];
	FILE *fp;
	fp = fopen("d.conf","rt");
	if(fp == NULL) return FALSE;
	c = fgetc(fp);
	while(c != EOF) {
		printf("%c", c);
		switch(c) {
		default:
			while(c != '\n') {
				if(c == '/') {

				}
				str[a] = c;
				a++;
			}
			str[a] = '\0';
			//getSet(str);
			break;
		}
		c = fgetc(fp);
	}
	fclose(fp);
	getchar();

rüdiger

was ist der Sinn des switch-Statements? Also dort gelangst du zumindest in eine Endlos-Schleife

btw EOF afaik ein int und kein char.

deine erste while schleife bringt null, rein gar nix (wie rüdiger schon gesagt hat das wird eh ne endlosschleife)! da sich c nie ändert bringt die switch anweisung auch nüscht, genauso wie die while schleife, und die if abfrage, und ...
hier mal ein bsp. wie man eine datei in einem rutsch einliest:

#include <stdio.h>

int main()
{
    char* buf;//hier wird nachher alles reinkopiert
    size_t size, i=0;//size=grösse der datei/anzahl der zeichen, i als Zählervariable
    FILE* f=fopen("C:\\text.txt","r");
    if(f==NULL)
        return 1;

    fseek(f, 0, SEEK_END);//hier wird ans ende der datei gefahren
    size=ftell(f);//die funktion gibt uns die position in der datei an, 
    //da wir aber am ende sind ist das gleichzeitig auch die anzahl aller zeichen

    buf=malloc(size);//für den buffer wird genausoviel speicher reserviert wie wir für die komplette datei brauchen.
    if(buf==NULL)//speicherreservierung erfolgreich?
        return 2;//Nein? programm beenden

    rewind(f);//nun wieder an den anfang der datei...
    while((buf[i]=fgetc(f))!=EOF)//... und solange das ende nicht erreicht ist, jedes zeichen einzeln einlesen
    {
        ++i;
    }

    buf[size-1]='\0';//nullternminierung anhängen...
    printf("%s\n", buf);//... dannach alles noch ausgeben
    free(buf);//wichtig! speicher wieder freigeben!
    return 0;
}

hoi,
ich habe jetzt leider keine lust mir das noch mal alles durch zulesen...
deshalb frag ich einfach mal, auch wenn die frage durch das lesen des codes überflüssig werden würde

ginge denn?

char c;
    int a = 0;
    char str[256];
    FILE *fp;
    fp = fopen("d.conf","rt");
    if(fp == NULL) return FALSE;
    c = fgetc(fp);
    while(!feof(fp)) {
        printf("%c", c);
        switch(c) {
        default:
            while(c != '\n') {
                if(c == '/') {

                }
                str[a] = c;
                a++;
            }
            str[a] = '\0';
            //getSet(str);
            break;
        }
        c = fgetc(fp);
    }

fclose(fp);
getchar();

hab jetzt leider keine lust mir den code durchzulesen...
deshalb sag ich einfach mal NEIN, es geht nicht!

der code ist übrigens nicht besser geworden... schau dir einfach den von snoopy an da wirds auch noch erläutert und das return FALSE; ist auch nicht so der renner. FLASE = 0 = programm wurde erfolgreich beendet... nimm stattdessen return EXIT_FAILURE; oder bei erfolg return EXIT_SUCCESS;

manu1984

Ersetze deine while-schleife + getc() einfach durch das hier.
müsste klappen *g*

while((c=fgetc(fp)) != EOF)
{
...
}

und das funktioniert in C?

@mister y:

ich hatte das hier verändert:

while(!feof(fp)) {

außerdem ist die Funktion vom Typ BOOL ._.

CStoll

Was soll denn die innerste while-Schleife überhaupt bewirken? Du füllst das Array str mit c-Werten, bis c sich irgendwann bemüht, den Wert '\n' anzunehmen. Aber im Inneren der Schleife änderst du c überhaupt nicht - eine klassische Endlosschleife (die dir vermutlich nach einiger Zeit von einem SegFault abgeschossen wird). Und ein switch(), das nur den default-Zweig hat, ist auch sehr sinnvoll

Und ja, die Konstruktion von manu funktioniert (allerdings solltest du c dafür als int anlegen) - die weist c den Rückgabewert von getch() zu und vergleicht den Wert dieses Zuweisungsausdrucks anschließend mit EOF (für Operator-Verkettungen ala "a=b=c;", aber auch für Konstruktionen wie dieses "while((c=getch())!=EOF)..." liefert die Zuweisung den kopierten Wert als Rückgabe).

Es ist nett, dass du mir hilfst, aber bitte bekleckere mich nicht mit deinem Halbwissen.
Habe ich jemals gesagt, dass die switch Kontrollstruktur vollständig sei?

Auch wenn ich bei der vorherigen Aussage kaum noch eine freundliche Antwort erwarten kann, frage ich trotzdem einmal die folgende Frage:

Am Ende der while Schleife steht doch, dass der sich den NÄCHSTEN Charakter holen soll, oder etwa nicht?

while(TRUE) {
c = fgetc(fp);
}

Oder muss ich den Cursor manuell immer eins weiter stellen?

CStoll

Mit der innersten Schleife meinte ich die Konstruktion IN dem switch-Block:

while(c != '\n') { 
  if(c == '/') { 
  } 
  str[a] = c; 
  a++; 
}

Dort hast du keine Anweisung, die den Inhalt von c ändert, also schreibt die Schleife so lange das zuletzt eingetippte Zeichen in den Speicher, wie dein Betriebssystem es zulässt.