Ich habe mehr oder weniger 2 Probleme bzw. Fragen. Erstmal die Geschichte:

Es handelt sich nicht um normale Textdateien sondern um Dateien mit der Endung ".pt". Es geht darum, dass ganze File "durchzuscannen" und alle "0x63" Werte rauszulöschen weil sie da drin unnötig sind und die Dateien nur zwecklos grösser machen (sogar ziemlich grösser). Ich habe mir dabei gedacht, dass das Programm erstmal alle Dateien aus dem Ordner und den Unterordnern ausliest den ich angegeben habe (habe ich bereits fertig). Danach erstellt es eine exakte "temporäre" Kopie aller File-Namen mit einer zusätzlichen ".pr" Endung (steht für PRocess). Also wenn jetzt z.B. ein File "12345.pt" heisst, wird ein leeres neues File erstellt welches "12345.pt.pr" heisst. Selber Name, zusätzliche Endung, kein Inhalt. Soweit sollte ich es noch schaffen. Jetzt zum eigentlichen Probem: Dem Scannen. Ich dachte mir, dass ich das File durchscannen lasse und alle Datentypen die NICHT "0x63" sind in dieses erstellte ".pr"-File speichere. Dies muss fast so sein weil man ja das File während dem scannen schlecht direkt verändern kann und es auch einfacher geht gerade alles was brauchbar ist in ein neues zu speichern. Am Schluss des Prozesses wird die originale ".pt" Datei gelöscht und die neue ".pr" Datei ohne diese "0x63" umbenannt resp. das ".pr" am Schluss weggenommen.

Jetzt zum eigentlichen Problem:

1. Wie kann ich ein File mit der Endung .pt öffnen um es weiterzuverarbeiten?
2. Wie lässt sich ein File so durchscannen nach Werten? Ich mein, es ist logisch dass ich eine if-Schleife machen muss die abfragt ob es gerade "0x63" ist aber das Ganze muss in einer do-while Schleife sein und ich peil deren Ablauf nicht.
3. Wenn ich das File mit einem Textbearbeitungsprogramm öffne sieht es ungefähr so aus (ist nur ein klitzekleiner Abschnitt): HIER KLICKEN . Wie kann ich nicht nach DEM Inhalt suchen sondern nach den Teilen da oben wie "0x63" etc?

Sind wahrscheinlich etwas schwerere Fragen aber hier gibt es auch jede Menge guter Coder die vielleicht einige Ansätze, Anregungen etc. geben können

Danke im Voraus

Devil

Scanner (NV6)
Datentyp: 0x63

Header:
1 Byte (BYTE) | 2 Byte (WORD) | 1 Byte (BYTE) | 1 Byte (CHAR)

Ich muss also immer den Header auslesen und nur falls es dieses 0x63 ist soll er nichts unternehmen und einfach weiterleen, ansonsten alles ins neue File speichern. Vielleicht könnte man was mit .read machen aber ich hab schon in der MSDN Library geschaut aber die hilft mir keinen Millimeter weiter.

//binär einlesen
	CFile cfb( filename , CFile::modeRead|CFile::typeBinary) ;
	DWORD lenB = cfb.GetLength() ; //grösse der einzulesenden datei
    unsigned int bmfArrLen;        //array länge	
    BYTE *bmfArr;                  //unsigned byte
      //falls es sich um short oder integers handelt einfach tyen ersetzen
	bmfArrLen = (lenB/sizeof(WORD)) ;
	bmfArr = new BYTE[bmfArrLen];  //unsigned short
	cfb.Read(bmfArr , lenB); 

      // jetzt liegt erstmal die ganze datei im BYTE Array bmfArr
      for(int i= 0 ; i < bmfArrLen ; i++)
      {
          if(bmfArr[i] != 0x63)
          {
             //in neues ByteArray schreiben und diese sichern
          }
      }
      cfb.Close();

Hy ,
du willst so wie ich das verstehe eine nicht textdatei öffen , byteweise abchecken ob es sich um 0x63 handelt oder nicht und alle nicht 0x63 info abspeichern ?

Genau.

Danke dir für den Aufwand! In der Abfrage selber sehe ich keinen Fehler aber er gibt mir an "C:datei.pt2 wurde nicht gefunden". Zuerst dachte ich er hat ein Problem mit dem übergeben des Pfades und habe kurz eine neue Variable erstellt und dort einen statischen Pfad deklariert. Doch komischerweise geht das auch nicht. Das File existiert 100%, den Pfade habe ich auch 100% richtig angegeben aber wie man sieht schneidet er das "\" nach "C:" ab, obwohl ich das geschrieben habe. Gibts ein spezielles Zeichen dafür oder wie seh ich das? So einen Fehler hab ich noch gar nie gesehen, hab schon öfter mit Pfaden gearbeitet.

Nun doch noch eine kurze Frage: Du speicherst ja in deinem Codeteil das ganze File in einem Array, das funzt ja auch wunderbar aber ich konnte dem Datenblatt gerade entnehmen, dass nicht alle 63-er gelöscht werden sollen sondern nur ganze sog. ScannerMeldungen. Das sind die mit dem Header den ich ein paar Posts vorher geschrieben habe. Sie haben z.B. im Header zuerst die Länge, danach der timestamp, dann der typ und schlussendlich die eigentlichen daten. Der Typ ist hierbei wichtig. Wenn der 63 ist sollte es übersprungen werden. Ich verlange kein komplett funktionstüchtigen Codeteil, ich würd nur gerne wissen wie ich das auslesen kann und wie danach weiterverarbeiten und ne Abfrage draus machen. Dass es mit .read gehen sollte weiss ich. Sorry wenn ich so viel Fragen stelle aber mir ist das ganze binärverarbetungszeugs irgendwie noch neu.

Achtung: Du musst dir überlegen wo (für bsp länge , also 4 bytes) das erste byte liegt und wo das letzte ..

Zum Programm zurück: Wie gesagt verstehe ich WAS GENAU er machen müsste damit ich zum gewünschten Ergebnis komme, ich peile aber nicht wie ich das realisieren soll. Hier erstmal die gesamte Funktion (filename ist nur vorübergehend statisch aus Testzwecken):

CString filename = "C:\\datei.pt2";
	CString prFilename = filename + ".pr";
	int arrayLenght;
	WORD *array;											                    //WORD = 16bit unsigned int

	CFile file(filename, CFile::modeRead);					                  //Open file (binary reading is standard) 
        DWORD fileLenght = file.GetLength();					                //Lenght of the current file (DWORD = 32bit unsigned int)

        arrayLenght = (fileLenght / sizeof(WORD));					          //WORD = 16bit unsigned int
        array = (WORD*) calloc(arrayLenght, sizeof(WORD));
        file.Read(array, arrayLenght*sizeof(WORD));					         //The whole file is in the BYTE Array 'array'

	WORD lenght;											                 //WORD = 16bit unsigned int		
	DWORD timestamp;										                 //DWORD = 32bit unsigned int
	BYTE type;											                   //BYTE = 8bit unsigned int

	BeginWaitCursor();

	CFile prFile(prFilename, CFile::modeCreate | CFile::modeWrite);             //Open the .pr File (ProcessFile)
	for(int i = 0; i < fileLenght; i++)
	{
		WORD varLenght = file.Read(&lenght, 2);                                  //Read the lenght (2 Byte)
		DWORD varTimestamp = file.Read(&timestamp, 4);                           //Read the timestamp (4 Byte)
		BYTE varType = file.Read(&type, 1);                                      //Read the type (1 Byte)

                DWORD data;
                DWORD varData = file.Read(&data, lenght);

		if(type != 63) 
		{
			prFile.Seek(0,CFile::end); 
			prFile.Write(lenght, 2);
			prFile.Write(timestamp, 4);
			prFile.Write(type, 1);
			prFile.Write(data, lenght);
		}
    }
	prFile.Close();                                                              //Close the ProcessFile

	EndWaitCursor();

	file.Close();										                        //Close the main-file
	free(array);											                     //Clear memory (IMPORTANT)

EDIT: Ich hatte nur n paar logische Fehler, jetzt sollte im oberen Part eigentlich soweit alles nicht schlceht sein. Hab nur Probleme mit dem write. Er sagt immer
"cannot convert parameter 1 from 'unsigned short' to 'const void *'". Wie kann ich das lösen? Danke im Voraus.

also zu deinem Parameterübergabeproblem :
ich nehme an du benutzt CFileDialog ?!
dann füge einfach den cast ein :

CString path =  cfd.GetPathName();
	//CString nach char* casten
     //LPCTSRT = long pointer const string
	char * szMyString = (char *) (LPCTSTR) path;

dann sollte es wieder funzen ...
PS. : deine for-schleife kannste optimieren .. mach ne while draus und überprüfe dann erst bei byte(zb 9)weiter .. nicht jedes byte durchgehen und checken.
Wieso eigentlich free? kannst doch delete [] arrayname machen ..

1.) weil du nirgends deine werte aus dem eingelesen array benutzt?
(willst du es überhaupt benutzen ansonsten muss du in der schleife
sowieso dafür sorgen das dein filepoiter vorwärtsgerücktwird )
2.) du immer die selben bytes interpretierst und für jedes byte!!
(so tun würdest als ob es ein header bate ist und somit immer 4+2+1 bytes
in die datei schreibst)

// dieser vorschlag gilt nur wenn du statt unsignde short byteweise einliest
// habe ich nicht getestet nur so provisorisch aufgestllt..
int i=0;
 WORD varLenght=0;
 DWORD varTimestamp=0;
 BYTE varType=0;

 while( i < fileLenght ) 
    { 
 //Read the lenght (2 Byte)
         varLenght = array[i]<<8 ;  
         varLenght = varLenght | array[i+1] ;            

 //Read the timestamp (4 Byte)         
         varTimestamp = array[i+2]<<24 ;                     
         varTimestamp = varTimestamp | array[i+3]<<16;
         varTimestamp = varTimestamp | array[i+4]<<8;
         varTimestamp = varTimestamp | array[i+5];

 //Read the type (1 Byte) 
         varType = array[i+6];  
 // falls die struktur dynmisch in der grösse ist .. hier anpassen 
    // ist dein data 2 bytes ? oder ist es danamisch
      // also sowas wie sizeof(length) = entspricht 2
      //oder in length ist der wert zb 20 , die anzahl der bytes   

        if(type != 63) 
        { 
            prFile.Seek(0,CFile::end); 
            prFile.Write(lenght, 2); 
            prFile.Write(timestamp, 4); 
            prFile.Write(type, 1); 
            prFile.Write(data, lenght); 
        } 
        i+=7; //anzahl bytes der struktur
         // falls die struktur dynmisch in der grösse ist .. hier anpassen
         //also die 7 ggf um 2 erhöhen oder den dynamischen wert.
         // i+=(7+lenght) ;
    }

Also jetzt nochmal für die steinmetze zum mitmeisseln..
Ich bin davon ausgegangen ,dass du den oberen teil von dir/mir übernimmst und es mit byte inliest..deshalb habe ich kein read() usw geschrieben ..(mitdenken..)

Ausdrucksbeschreibung:
varTimestamp = varTimestamp | array[i+3]<<16;
//shifte das i+3 byte um 2 byte nach links //4 3 2 1
//weil varTimestamp (4 byte type) ist, steht jetzt das i+3 byte 0x00**0000 an
//der ** position

//i+=7; ist das gleiche wie i= i+7 nur kürzer .. sollte aber bekannt sein

das mit dem schreiben könntest du auch anders machen ..
in einem zusätzleichen array speichern ..und am ende alles schreiben..
So muss jetzt leider nach hause..
und kann erst morgen wieder reinschauen (mein arbeitgeber sei dank*g*)..

habe so das gefühl du schriebst wieder*g*
cu Andreas

Für die die es noch interessiert noch die fertige Scanfunktion:

BOOL CScanFilterDlg::ProcessFile(CString currentFile)
{
	UpdateData(TRUE);

	int			arrayLenght;
	int			i = 0;
	BOOL		   ok;
	CString		file;
	CString		prFilename = currentFile + ".pr";
	WORD		   varLenght = 0;
	DWORD		  varTimestamp = 0;
	BYTE		   varType = 0;
	BYTE		   *array;

	CFile cfile(currentFile, CFile::modeRead);							//Open file (binary reading is standard) 
    DWORD fileLenght = cfile.GetLength();

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////SAVE THE WHOLE FILE IN AN ARRAY//////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	arrayLenght = (fileLenght / sizeof(BYTE));
    array = (BYTE*) calloc(arrayLenght, sizeof(BYTE));
    cfile.Read(array, arrayLenght*sizeof(BYTE));

	CFile prFile(prFilename, CFile::modeCreate | CFile::modeWrite);		//Create ProcessFile

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////MOST IMPORTANT SCANNING LOOP/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	while(i < fileLenght)
	{
		//Read the Lenght (2 Byte)
        varLenght = array[i];  
        varLenght = varLenght | array[i + 1] << 8;            

		//Read the Timestamp (4 Byte)        
        varTimestamp =				array[i + 2] << 24;                    
        varTimestamp = varTimestamp | array[i + 3] << 16;
        varTimestamp = varTimestamp | array[i + 4] << 8;
        varTimestamp = varTimestamp | array[i + 5];

		//Read the Type (1 Byte)
        varType = array[i + 6]; 

		if(varType != 0x63)
		{
			prFile.Seek(0,CFile::end);									//Jump to End of File
			prFile.Write(&array[i], (7 + varLenght));					//Write whole Message
		}

		i = (i + 7 + varLenght);										//Set Cursor on next MessageStart
    }

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////COMPLETE PROCESS BY CLOSING, DELETING AND RENAMING THE NECESSARY FILES///////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	cfile.Close();														//Close OldFile
	prFile.Close();														//Close ProcessFile

	cfile.Remove(currentFile);											//Remove OldFile
	prFile.Rename(prFilename, currentFile);								//Rename ProcessFile

	free(array);														//Clear Memory (IMPORTANT)

	return ok;															//Return ok

	UpdateData(FALSE);
}