[c]Datei Durchsuchen/Ausgeben

[Anzi-C]

Für die Adresse reichen sicher nicht 10 Zeichen. Ich würde die Adresse in Straße, PLZ und Ort aufteilen.

Lies dich mal in die Funktion fscanf() ein, mit der dürftest du dein Problem lösen können.

[opener]

Anzi-C schrieb:

Für die Adresse reichen sicher nicht 10 Zeichen. Ich würde die Adresse in Straße, PLZ und Ort aufteilen.

Lies dich mal in die Funktion fscanf() ein, mit der dürftest du dein Problem lösen können.

naja, die zeichen könnte man ja verlängern, aber ich werde es aufteilen, da hast du recht, das ist um einiges besser.

besten dank für die info mit fscanf()!
wenn man gerade angefangen hat zu programieren kennt man halt die ganzen fuktionen noch nicht so richtig

mfg
opener

[Anzi-C]

wenn man gerade angefangen hat zu programieren kennt man halt die ganzen fuktionen noch nicht so richtig

Ich weiß, solange programmiere ich in C auch noch nicht aber dafür ist ja das Forum da!

Alternativ kannst du auch mal nach "String Tokenizer" suchen, das geht vielleicht einfacher. Im Forum habe ich mal dazu eine kurze aber praktische Funktion gesehen, vielleicht findest du sie ja wieder!

[opener]

hi,

Alternativ kannst du auch mal nach "String Tokenizer" suchen, das geht vielleicht einfacher.

ich habe mal nach dem String Tokenizer Gegoogelt, leider finde ich nur sachen über Java

das mt dem fscanf() funktioniert leider auch nicht, da der straße name ja meistens aus mehreren wörtern besteht. "garten straße", "Baum Ale" etc... und der fscanf() gerkennt die beiden wörter natürlich als als 2 strings und nicht als einen

mfg
opener

[Anzi-C]

Mit fscanf(fp, "[^\t]", string) erreichst du, dass bis zu einem Tabulator gelesen wird. Ich empfehle dir allerdings folgende Methode:

char tmp[ZEILEN_LAENGE] = "";

fgets(tmp, ZEILEN_LAENGE, fp);
sscanf(tmp, "%[^\t]\t%[^\t]", string1, string2);

Zuerst die komplette Zeile einlesen und dann mit sscanf() in mehrere Strings aufteilen.

Das sscanf() musst du dann nur noch anpassen.

[opener]

Hi,

danke für den Tip sscanf()!

Also, ich habe das ganze jetzt so "gelöst":

while(c != EOF)
			{
  		c = fgetc(ptr_Datei);

 			if(c == ';')
   		// printf("Hier beginnt, bzw. endet (je nachdem wie man's siehst) eine spalte\n");

  		if(c == '\n')
  		  printf("Hier ist die Zeile zu ende und mit dem naechsten Zeichen beginnt die naechste Zeile\n");
		} 
				rewind(ptr_Datei); // setzt den filepointer (ptr_Datei) wieder auf den anfang der datei

				while(c != EOF)
		{
 				c = fgetc(ptr_Datei);
  			if(c == ';')
  	{
   	//		printf("Hier endet die spalte\n");
  		  mein_string[i] = '\0'; //ein string sollte immer mit dem zeichen '\0' abgeschlossen werden
  		 printf(mein_string);
  		  break; //verlässt die while-Schleife
  	}
  		else
 	 {
    mein_string[i] = c;
    i++;
 	 }
	}

Nun möchte ich aber ja das wenn ich die Nummer oder Name eintippe/scanne auch der richtige Datenzatz mit den Infos angezeigt wird.
Ich habe dazu im i-net was gestöbert und bin auch diese Funktion hier gestoßen: strcmp() mit der man Strings vergleichen kann. Leider weiß ich nicht ob man das damit umsetzen kann?

mfg
opener

[Anzi-C]

Könntest du noch mal etwas compilierbares posten, dann tun wir uns leichter!

[opener]

Klar kein problem.

Das ist die komplete c Datei:

/*************************************************************************/
/*          Include Files                                                */
/*************************************************************************/
#include <include\dos.h>
#include <include\io.h>
#include <include\conio.h>
#include <include\string.h>
#include <include\stdlib.h>
#include <include\stdio.h>
#include <include\malloc.h>
#include <include\fcntl.h>
#include <include\graph.h>
#pragma pack(1)
#include <include\sys\types.h>
#include <include\3000\urm.h>
#include <include\3000\dos.h>
#include <include\3000\bios.h>
/**************************************************************************/
/*          Local Constant Definitions                                    */
/**************************************************************************/
#define   REVERSE         0x70
#define   NORMAL          0x07
#define   KEYS_ONLY       0
#define   KEYS_AND_LABELS 1
#define   LABELS_ONLY     2
#define   FROM_KEY        0
#define   FROM_CONTACT    1
#define   FROM_LASER      2
#define 	KEY_CLEAR	      0x001B
#define		KEY_BACKSPACE	  0x0008
#define 	ERROR		     	 -1
#define		NO							0
#define 	YES							1
#define   ERROR_NO	      0
/**************************************************************************/
/*           Public Function Declarations                                 */
/**************************************************************************/
int from_label(int handle);
void scannen(char *databuf);
void beleg();
short MainMenu(short selection);
void GetData(unsigned char mode, short line, short column, short width, char *data_buffer);
void nochmal();
void info();
byte labeltype;
int con_handle;
int BelegeSpeichern(void);
char store_number[6];
short Initialize(void);

 struct s_Kunden
{
	int nummer;
	char nachname[30+1];
	char strasse[30+1];
	char ort[25+1];
	int plz;
	int tele;
	char rabat[5];
	char flag1[1];
	char flag2[1];
	char flag3[1];
	char flag4[1];
 }s_KundenData;

 struct s_Artikel
 {
 	int nummer;
 	char code[10];
 	char bezeichnung[10];
 	char topfg[10];
 	char hoehe[10];
 	int preis;
 	int mwst;
 	int rabatsperre;
 	int rabatffeahig;
 	char flag1[1];
 	char flag2[1];
 	char flag3[1];
}s_ArtikelData;

 struct s_Belege
 {
 	char zahlungsart[10];
 	char store_number[6];
 }s_BelegeData;

 /***************************************************************************/
 /***************************************************************************/
 /***************************************************************************
int BelegeSpeichern(void)
{
	FILE *ptr_Datei;

	ptr_Datei = fopen( "D:belege.txt", "a" ) ; 
	if( ptr_Datei == NULL ){
		fprintf( stderr, "\nFehler beim Oeffnen der Datei!\n" );
		return -1;
	}
	else{
    		fwrite( &s_BelegeData, sizeof( s_BelegeData ), 1, ptr_Datei );
  		fclose( ptr_Datei);
		return 0;
	}

}
/**************************************************************************/
/* Function name : from_label()                                           */
/* Purpose : Determine if last input was from label and return number of  */
/*           label chars left to read                                     */
/**************************************************************************/
int from_label(int handle)
{
  IoctlT iob;

  /* Get last char read status */
  iob.funcode = ConsIoctlGetCharStatus;
  DosIoCtrlRdData(handle,&iob,ConsIoctlGetCharStatusLen);

  /* If it was from a label, return length remaining */
  if ( ( iob.data.charstatus.source == FROM_CONTACT ) ||
       ( iob.data.charstatus.source == FROM_LASER ) )
  {
    labeltype = iob.data.charstatus.labeltype;
    return(iob.data.charstatus.labellen);
  }
  else
    return(FALSE);

}

/**************************************************************************/
/* Function name : main()                                                 */
/* Purpose : entry point of this program.                                 */
/**************************************************************************/
main(int argc, char *argv)
{
	char errorlevel;
	short selection;
	char data[30];
	/*	scannen(data);
	puts(data);*/	

	FILE  *ptr_Datei;

	ptr_Datei = fopen( "kunden.txt", "r" );
	if( ptr_Datei == NULL ){
		fprintf( stderr, "\nFehler beim Lesen der Datei Kunden!\n" );
		return -1;
	}
	/*
	FILE  *beleg_Datei;

	beleg_Datei = fopen( "Belege.txt", "a" );
	if( beleg_Datei == NULL ){
		fprintf( stderr, "\nFehler beim Lesen der Datei Belege!\n" );
		return -1;
	}*/

if ( (errorlevel = Initialize()) == ERROR_NO ) {
	for ( selection = 1; selection; ) {
    switch ( selection = MainMenu(selection) ) {
      case 1:
	beleg();
	break;
			case 2:
	scannen(data);
	break;
			case 3:
	system("tdrem.exe -rs4=115000");
	break;
			case 4:
	info();
	break;			
		  }
   }
   exit(errorlevel);
	}
}
/* INITIALIZATION ROUTINE */
/* - SETS UP THE COMMUNICATION PROTOCOL AND PORT PARAMETERS */
short Initialize(void)
{
SEPCHART com_inp_separators;
SEPCHART com_out_separators;
unsigned int device_info;
short errorlevel;
int handle;
IoctlT ioctl;

errorlevel = ERROR_NO;

if ( !errorlevel ) {
			printf("AutoNr: ");

  }
return(errorlevel);
}
/* MAIN MENU ROUTINE */
/* - DISPLAY THE MENU ENTRIES, PROMPT FOR A SELECTION */
short MainMenu(short selection)
{	
static char *menu_entry[] = {
  "1 = BELEG ERFASSEN",
  "2 = NOCHMAL DRUCKEN",
  "3 = DATEN ABGLEICH",
  "4 = SOFTWARE INFOS",
   };

  char choice[2];
	unsigned char line;
	short loop;
	short valid;

  BiosClrScr(NORMAL);
	BiosPutStrMove(0, 5, 10, "HAUPT MENU", NORMAL);
		for (line = 2, loop = 0; loop < 4; loop++, line++ )
  BiosPutStrMove(line, 1, strlen(menu_entry[loop]), menu_entry[loop], NORMAL);
	BiosPutStrMove(7, 2, 14, "Bitte weahlen:", REVERSE);
		for ( valid = NO; !valid; ) {
  	GetData(KEYS_ONLY, 7, 17, 1, choice);
   		 selection = atoi(choice);
 		if ( selection >= 1 && selection <= 4 )
      valid = YES;
    else
   		BiosBeep(300);
  }
return(selection);
}

void scannen(char *databuf) {

  int scanhandle;
	int alldone;

  int count;
  int location,state;
  int left;
  byte old_gas=0;
  int initime,scantime;
  IoctlT iob;
  char ausgabe[30];

  /* Open scanning handle */
  DosOpen("CON",READONLY,&scanhandle);

  /* Configure scanning */
    /* Set binary mode */
  DosIoCtrlSetInfo(scanhandle,DosIoCtrlGetInfo(scanhandle)|RAWMODE);

  /* Read old scan parameters */
  iob.funcode = ConsIoctlGetScanParms;
  DosIoCtrlRdData(scanhandle,&iob,ConsIoctlScanParamLen);

  /* Change timeout to a long time */
  iob.data.scanparms.inactivetime = 255;

  iob.data.scanparms.initscantime = 3;
  iob.data.scanparms.subsscantime = 3;
  iob.data.scanparms.postdecodeact = 1;
  iob.data.scanparms.decodefailact = 2;

  /* Select label terminator */
  iob.data.scanparms.labeltermchar = 0;

  /* Beep for 1/10 second when label scanned */
  iob.data.scanparms.beepondecode = TRUE;
  iob.data.scanparms.beeptime = 100;

  /* Select new parameters */
  iob.funcode = ConsIoctlSetScanParms;
  DosIoCtrlWrData(scanhandle,&iob,ConsIoctlScanParamLen);

  /* Not done yet */
  alldone = FALSE;

  /* Turn on scanning - allow scan ahead */
  iob.funcode = ConsIoctlScanState;
  iob.data.scanstate.scan_state = 1;
  DosIoCtrlWrData(scanhandle,&iob,ConsIoctlScanStateLen);

  /* Select input mode and label timeout  - required */
  iob.funcode = ConsIoctlSetInputMode;
  iob.data.inputmode.inmode = KEYS_AND_LABELS;
  iob.data.inputmode.labeltimeout = 255;
  DosIoCtrlWrData(scanhandle,&iob,ConsIoctlSetInputModeLen);

  /* Continue until we are asked to stop */

  while ( !alldone)
  {

    DosRead(scanhandle,databuf,1,&count);
   /* If we got a character */
    if ( count )
    {
      /* If it came from a label, get the rest */
      if ( left = from_label(scanhandle) )
      {
        /* Read rest of label */
        if ( left > 1 )
          DosRead(scanhandle,databuf+1,left-1,&count);

        /* Set teminator */
        databuf[left] = 0;
				if(databuf=="0" || databuf=="1" || databuf=="2" || databuf=="3" || databuf=="4" || databuf=="5" || databuf=="6" || databuf=="7" || databuf=="8" || databuf=="9")
				{

        } 
        else
        {
        alldone = TRUE;
        printf(databuf);
        }
   	  }
    }
  }
  /* Turn scanning off */
  /* Turn off scanning - needed if scanning was turned on */
  iob.funcode = ConsIoctlScanState;
  iob.data.scanstate.scan_state = 0;
  DosIoCtrlWrData(scanhandle,&iob,ConsIoctlScanStateLen);

  /* Reset to read only keys from the console */
  iob.funcode = ConsIoctlSetInputMode;
  iob.data.inputmode.inmode = KEYS_ONLY;
  iob.data.inputmode.labeltimeout = 255;
  DosIoCtrlWrData(scanhandle,&iob,ConsIoctlSetInputModeLen);

  /* Close scanning handle */
  DosClose(scanhandle);
  /* Clear screen, home cursor */

}
/* GET DATA ROUTINE */
/* - A CRUDE BUT USEFUL ROUTINE TO MANAGE DATA ENTRY BY KEYBOARD OR SCANNER */
void GetData(unsigned char mode, short line, short column, short width, char *data_buffer)
{
char blanks[21];
int bytes;
char character[2];
char *data;
IoctlT ioctl;
short key_pressed;

memset(blanks, ' ', 21);
blanks[width] = '\0';
memset(data = data_buffer, 0, width + 1);
ioctl.funcode = ConsIoctlSetInputMode;
ioctl.data.inputmode.inmode = mode;
ioctl.data.inputmode.labeltimeout = 30;
DosIoCtrlWrData(con_handle, &ioctl, ConsIoctlSetInputModeLen);
do {
  BiosPutStrMove((unsigned char)line, (unsigned char)column, strlen(blanks), blanks, NORMAL);
  if ( strlen(data_buffer) )
    BiosPutStrMove((unsigned char)line, (unsigned char)column, strlen(data_buffer), data_buffer, NORMAL);
  BiosSetCursorPos((unsigned char)line, (unsigned char)(column + strlen(data_buffer)));
  DosRead(con_handle, character, 1, &bytes);
  if ( !(key_pressed = character[0]) ) {
    DosRead(con_handle, character, 1, &bytes);
    key_pressed = character[0];
    key_pressed = key_pressed << 8;
    }
  switch ( key_pressed ) {
    case KEY_CLEAR:
      memset(data = data_buffer, 0, width + 1);
      break;
    case KEY_BACKSPACE:
      if ( strlen(data_buffer) == 0 )
	BiosBeep(300);
      else
	*--data = '\0';
      break;
    default:
      if ( key_pressed != '\r' )
	if ( strlen(data_buffer) == width )
	  BiosBeep(300);
	else
	  *data++ = key_pressed;
      break;
    }
  } while ( key_pressed != '\r' );
}

void beleg()
{
	char data[30];
	short error_detected;
	short quit;
	char mein_string[128]; 
	char c;
	int i = 0;

	FILE  *ptr_Datei;

	ptr_Datei = fopen( "kunden.txt", "r" );
	printf("hier");
	scannen(data);
	puts(data);
		/*

	BiosClrScr(NORMAL);
			BiosPutStrMove(0, 2, 13, "Kunde Weahlen", NORMAL);

			BiosPutStrMove(2, 0, 11, "Kunden Nr.:", NORMAL);
  		BiosPutStrMove(4, 0, 12, "Kunden Name:", NORMAL); 
  		GetData(KEYS_ONLY, 2, 10, 12, data);
  		scannen(KEYS_AND_LABELS, 2, 10, 12, data);
			GetData(KEYS_ONLY, 4, 10, 12, data);
			*/
			while(c != EOF)
			{
  		c = fgetc(ptr_Datei);

 			if(c == ';')
   		// printf("Hier beginnt, bzw. endet (je nachdem wie man's siehst) eine spalte\n");

  		if(c == '\n')
  		  printf("Hier ist die Zeile zu ende und mit dem naechsten Zeichen beginnt die naechste Zeile\n");
		} 
				rewind(ptr_Datei); // setzt den filepointer (ptr_Datei) wieder auf den anfang der datei

				while(c != EOF)
		{
 				c = fgetc(ptr_Datei);
  			if(c == ';')
  	{
   	//		printf("Hier endet die spalte\n");
  		  mein_string[i] = '\0'; //ein string sollte immer mit dem zeichen '\0' abgeschlossen werden
  		 printf(mein_string);
  		  break; //verlässt die while-Schleife
  	}
  		else
 	 {
    mein_string[i] = c;
    i++;
 	 }
	} 
}
void info()
{
	BiosClrScr(NORMAL);
	BiosPutStrMove(0, 2, 13, "Software Info", NORMAL);
	BiosPutStrMove(0, 0, 23, "Version: 1.0 - 28.06.06", NORMAL);
}

Als exe kann man das ganze natürlich nicht ausführen! Da es ja für ein Handscanner programiert wird.

mfg
opener

[Anzi-C]

Okay mit dem habe ich jetzt nicht gerechnet..

Nun möchte ich aber ja das wenn ich die Nummer oder Name eintippe/scanne auch der richtige Datenzatz mit den Infos angezeigt wird.
Ich habe dazu im i-net was gestöbert und bin auch diese Funktion hier gestoßen: strcmp() mit der man Strings vergleichen kann. Leider weiß ich nicht ob man das damit umsetzen kann?

Wo sind denn die Daten gespeichert in einer Struktur? Möchtest du die Struktur füllen, durchsuchen, leeren usw.?

Mit strcmp() ginge das z.B. so:

if(!strcmp(s_KundenData.nachname, "Hugo")) printf("Passt.");

[opener]

Die Daten sind in einer .txt Datei gespeicher

12345,hopf,große gaße 3,00000,entenhausen,03341235609,5,0,0,0,0
23456,maier,hauptstr. 12a,12000,darkcity,0223486745,1,0,0,0,0
99999,hans,gartenweg 23,00000,entenhausen,03341235490,0,0,0,0,0

"die , sollten eigendlich ; sein habe ich noch nicht geändert."

So weit ich weis braucht man immer eine Struktur sobald man was mit Daten aus einer Datei machen möchte, und die ist ja auch vorhanden:

struct s_Kunden
{
    int nummer;
    char nachname[30+1];
    char strasse[30+1];
    char ort[25+1];
    int plz;
    int tele;
    char rabat[5];
    char flag1[1];
    char flag2[1];
    char flag3[1];
    char flag4[1];
 }s_KundenData;

Ich drucke das jetzt mal so aus wie ich denke das man das am besten verstehen kann
Ich möchte eigendlich nur das wenn ich eine Nummer oder den Namen Eintippe/Scanne mir aus der kunden.txt der richtige kunde herausgesucht wird und mit den Infos Nummer Name Tele Adresse Rabt angezeigt wird.

Deswegen dachte ich das man einfach nur den eigetippten/eingescannten Strig mit dem aus der Kunden.txt vergleichen müsste.

mfg
opener

[Anzi-C]

Dazu liest du einfach eine Zeile aus der TXT-Datei in die Struktur ein und vergleichst dann den eingegebenen String mit dem aus der Struktur. Wenn die Übereinstimmung negativ ist, nächste Zeile einlesen und wieder vergleichen. Das sollte sich relativ einfach mit einer Schleife lösen lassen.

[opener]

Du sagst das so leicht, wenn das so einfach für mich wäre breuchte ich keine 2 Tage dafür

Ich habe keine ahnung von C und habe wie schon im ersten Post geschrieben gerade die Ausbildung angefangen. Leider kann hier in der Firma keiner C und so haben sie mir das einfach mal in die Schuhe geschoben

Also noch mal zum Code:

while(c != EOF)
			{
  		c = fgetc(ptr_Datei);

 			if(c == ';')
   		// printf("Hier beginnt, bzw. endet (je nachdem wie man's siehst) eine spalte\n");

  		if(c == '\n')
  		  printf("Hier ist die Zeile zu ende und mit dem naechsten Zeichen beginnt die naechste Zeile\n");
		} 
				rewind(ptr_Datei); // setzt den filepointer (ptr_Datei) wieder auf den anfang der datei

				while(c != EOF)
		{
 				c = fgetc(ptr_Datei);
  			if(c == ';')
  	{
   	//		printf("Hier endet die spalte\n");
  		  mein_string[i] = '\0'; //ein string sollte immer mit dem zeichen '\0' abgeschlossen werden
  		 printf(mein_string);
  		  break; //verlässt die while-Schleife
  	}
  		else
 	 {
    mein_string[i] = c;
    i++;
 	 }
	}

Hier wird doch die Zeile eingelesen?! oder sehe ich das Falsch?

aber wie kann man den die zeile aus der txt in die Struktur laden?

EDIT: Kann mir vieleicht jemand sagen wo ich in dem Code der oben gepostet ist dann die "strcmp()" Funktion einbauen muss? damit die strings verglichen werden?

mfg
opener

[opener]

Hallo nochmal

ich habe nun noch eine andere möglichkeit die etwas einfacher ist ;):

char line[LINE_SIZE];
    char* delim = ",";
    char* word = NULL;
    int i = 0;

while(fgets(line, LINE_SIZE, ptr_Datei) != NULL){

        word = strtok(line, delim);

        for(i = 0; word != NULL; i++){

            if(i == 0){

                printf("%s\n", word);

                break;

           }

            word = strtok(NULL, delim);

        }

    }

    fclose(ptr_Datei);

    return 0;

Leider kann ich diesen nicht Compillieren da ich immer den C2062 Error erhalte.
Ich arbeite mit dem Windowscompiler in der Eingabeauforderung. (Version 8.00).

Irgent wie wird bei mir die Mircosoft Seite wo steht wie man das behaben kann http://support.microsoft.com/default.aspx?scid=kb%3Bde%3B113118 nicht richtig angezeigt...(es ist kein text zu sehen )

Wäre super wenn mir jemand sagen könnte was ich machen muss damit ich das Compillieren kann.

[keksekekse]

google doch mal nach '2062'

Die Zeileninhalt, wo der Fehler auftritt, wäre auch sehr aufschlußreich. Müsste etwas mit einer struct class oder type(def) sein.

Hier hab ich stricmp eingebaut.

char line[LINE_SIZE]; 
  char* delim = ","; 
  char* word = NULL; 
  int i = 0; 
  int stop = 0;

  while(fgets(line, LINE_SIZE, ptr_Datei) != NULL)
    { word = strtok(line, delim); 
      for (i = 0; word != NULL && i < 2; i++)
        { if (i == 0)
            { printf("%s\n", word); 
              break; 
            }
           else
          if (i == 1)
            { if (stricmp(word, "mueller-luedenscheid") == 0)
                { printf("Nr. %s\n", line);
                  stop = 1;
                  break;
                }
            }
          word = strtok(NULL, delim); 
        } 
      if (stop)
          break;
    } 
  fclose(ptr_Datei); 
  return 0;

[Tobias Gerg]

Hallo opener,

Ich war mal so frei, eine Funktion zu entwerfen, mit der Du in deiner Datei beispielsweise nach den Namen suchen kannst.

Rückgabewert der Funktion:

1 = gefunden
0 = nicht gefunden
-1 = fehler beim öffnen der Datei

Ein Wort zur Fehlerbehandlung.
Die ist nur rudimentär: (bei atoi prüfen ob es Zahl ist besser strtod Funktion verwenden)

Nichts desto trotz kann dass vielleicht als Ansatz helfen...

int FindeKunde(s_Kunden* Kunde, char* Name)
{
	// Deklarationen
	FILE* f				= NULL;		// Filepointer
	int zeichenZaehler  = 0;		// Zählt die Zeichen für eine String
	int strukturZaehler = 0;		// Navigation in der Struktur

	char zeichen;					// aktuelles Zeichen
	char aktuellerString[30 + 1];	// Hält den aktuellen String (30 + 1 weil
									// der größte String maximal 30+1 lang ist)

	// Datei öffnen (hier aktuellen Pfad der Datei mitberücksichtigen)
	f = fopen("Datei.txt", "r");	// lesender Zugriff

	if(!f)
	{
		printf("Unable to open file!\n");
		return -1;
	}

	//Solange nicht das Ende der Datei erreicht ist
	while(!feof(f))
	{
		//Lies ein Zeichen
		zeichen = fgetc(f);

		// Bei komma haben wir ein Element fertig
		if(zeichen == ',')
		{
			aktuellerString[zeichenZaehler] = '\0';

			zeichenZaehler = 0;

			//Kopieren der Daten in die Struktur
			switch(strukturZaehler)
			{
			case 0:					//Nummer
				Kunde->nummer = atoi(aktuellerString);
				strukturZaehler++;
				break;
			case 1:					//Name
				strcpy(Kunde->nachname, aktuellerString);
				strukturZaehler++;
				break;
			case 3:					//Strasse
				strcpy(Kunde->strasse, aktuellerString);
				strukturZaehler++;
				break;
			case 4:					//PLZ
				Kunde->plz = atoi(aktuellerString);
				strukturZaehler++;
				break;
			case 5:					//Ort
				strcpy(Kunde->ort, aktuellerString);
				strukturZaehler++;
				break;
			case 6:					//Telefon
				Kunde->tele = atoi(aktuellerString);
				strukturZaehler++;
				break;
			case 7:					//ab hier Rabatt und Flags
				strcpy(Kunde->rabat, aktuellerString);
				strukturZaehler++;
				break;
			case 8:
				Kunde->flag1 = zeichen;
				strukturZaehler++;
				break;
			case 9:
				Kunde->flag2 = zeichen;
				strukturZaehler++;
				break;
			case 10:
				Kunde->flag3 = zeichen;
				strukturZaehler++;
				break;
			case 11:
				Kunde->flag4 = zeichen;
				strukturZaehler++;
				break;
			}
		}
		// Ein neuer Datensatz beginnt (evtl. Kombinationen '\n\r' berücksichtigen)
		else if(zeichen == '\n')
		{
			strukturZaehler = 0;
			zeichenZaehler = 0;

			if(strcmp(Kunde->nachname, Name) == 0)
				return 1;

			//hier muss evtl. noch die Struktur gelöscht werden
		}
		// Einfach nur String erweitern
		else
		{
			aktuellerString[zeichenZaehler] = zeichen;
			++zeichenZaehler;
		}

	}
	//Falls letzter Datensatz nicht mit '\n' abgeschlossen ist
	if(strcmp(Kunde->nachname, Name) == 0)
		return 1;

	fclose(f);

	return 0;
}

Der Aufruf funktioniert so:

int main(void)
{
	s_Kunden gesuchterKunde;
	if(FindeKunde(&gesuchterKunde, "blablabla") == 1)
		printf("%d, %s", gesuchterKunde.nummer, gesuchterKunde.nachname);
	else
		printf("Nicht gefunden!\n");
	getchar();
	return 0;
}

[Swordfish]

Ich hab' jetzt nicht alles gelesen (zu müde), aber was haltet ihr von fscanf( )?

Greetz, Swordfish

[Tobias Gerg (off)]

Jupp, wäre natürlich auch ne Möglichkeit...
Gruss
Tobi

[Swordfish]

die wohl IMNSHO die eleganteste für solche Zwcke in reinem C

Greetz, Swordfish