4. [c]Datei Durchsuchen/Ausgeben

[c]Datei Durchsuchen/Ausgeben

  • O

    Guten Morgen erst einmal 🙂
    so früh und schon ein problem.

    Also ich habe gerade meine ausbildung angefangen und bin da bei wie alle Anfänger ein Handscanner in C zu programieren

    Nun da ich haber eigendlich keine ahnung von c habe, stehe ich nun vor einem kleinen problem.

    Ich habe eine .txt Datei mit Kundendaten:

    12345    hopf    große gasse 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 Daten sind alle durch ein Tab gerent, der nächste Kunde steht halt in der Zeile drunter.

    Nun möchte ich gerne diese Datei durchsuchen und nach einem Kunden suchen um diesen aufrufen zu können.
    Es sollen aber nur Nummer und Name durchsucht werden!

    nach dem

    Kunden_Datei = fopen( "D:kunden.txt", "a" ) ;

    hört es bei mir allerdings auf, da ich keine ahnung habe wie ich das ganze umsetzen muss.

    meine struktur sieht folgenermassen aus:

    struct s_Kunden
{
    char nummer[50+1];
    char nachname[50+1];
    char adresse[10+1];
    int tele;
    char rabat[5+1];
    char flag1;
    char flag2;
    char flag3;
    char flag4;
 }s_KundenData;

    Es wäre nett wenn mir jemand behilflich sein könnte

    mfg
    opener

    0
  • E

    Hi!

    Wenn du hier im richtigen Forum bist, würde ich dir CStdioFile empfehlen, das kann zeilenweise in CString einlesen und da wird das Zerlegen ziemlich einfach. 🙂
    CStringArray gibt es auch noch, was helfen kann.

    Falls du aber mit C arbeiten musst, bist du hier falsch und ich würde dich verschieben. 😉

    0
  • O

    ich muss mit C arbeite. Ich dachte ich wäre hier richtig da das Forum C/C++ heist 😉
    ich denke mal CStdioFile wird es dann unter C nicht geben 😞

    dann bitte einmal ins richte forum verschieben 😉
    aber danke für die info!

    mfg
    opener

    0
  • E

    C/C++ hat viiiiiiiiele Untergruppen. 😉

    0
  • C

    Dieser Thread wurde von Moderator/in estartu aus dem Forum MFC (Visual C++) in das Forum ANSI C verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.

    0
  • A

    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.

    0
  • O

    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

    0
  • A

    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!

    0
  • O

    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

    0
  • A

    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.

    0
  • O

    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

    0
  • A

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

    0
  • O

    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

    0
  • A

    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.");
    0
  • O

    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

    0
  • A

    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.

    0
  • O

    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

    0
  • O

    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.

    0
  • K

    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;
    0
  • T

    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;
}
    0

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

    Greetz, Swordfish

    0
Anmelden zum Antworten