Ich möchte eine Datei, welche mit FindFirstFile() gefunden wurde mit ifstream öffnen. Ist das überhaupt möglich? Oder muss ich die Sache ganz anders angehen?

#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <string>
#include <iostream>
#include <fstream>
#include <dos.h>

using namespace std;

WIN32_FIND_DATA fileData;
HANDLE fileHan;

int main(){

string filename;
fileHan = FindFirstFile("C:\\*.txt", &fileData);

while (true){
    FindNextFile(fileHan, &fileData);

    if (filename == fileData.cFileName){
        break;
        }

    filename = fileData.cFileName;

    if(fileHan == INVALID_HANDLE_VALUE){
        cout << "Process Failed";
        }
        else {
            cout << "The first File found is " << filename<<endl;
            }

}//end while
ifstream fin("C:\\" + filename);
    if(fin){
        cout<<"file found";

        }
FindClose(fileHan);

return(0);

}//end main

?

Danke für die schnelle Antwort!!!
das scheint so zu funktionieren!!!

Könntest Du mir vllt auch noch erklären warum das so sein muss?

Thx

zum Schluss soll noch eine neu Datei mit erweitertem Inhalt (Zuvor ausgelsener + neuer Text) erzeugt werde.

Das macht es auch , allerdings nur zu einer Datei und nicht zu allen welche er findet...

#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <string>
#include <iostream>
#include <fstream>
#include <dos.h>

using namespace std;

WIN32_FIND_DATA fileData;
HANDLE fileHan;

int main(){

char zeile [1024];
string Seite [100];

int k=0;
while(k< 2) {

string filename;

fileHan = FindFirstFile("C:\\*.txt", &fileData);

while (true){
    FindNextFile(fileHan, &fileData);

    if (filename == fileData.cFileName){
        break;
        }

    filename = fileData.cFileName;

    if(fileHan == INVALID_HANDLE_VALUE){
        cout << "Process Failed";
        }
        else {
            cout << "The first File found is " << filename<<endl;
            }

}//end while

/*ifstream fin(("C:\\" + filename).c_str());
    if(fin){
        cout<<"file found";

        }
*/
ifstream dateiLese(("C:\\" + filename).c_str());
if (dateiLese){                             // Wenn Datei vorhanden....
ofstream dateiSchreibe (("C:\\" + filename+ ".ixm").c_str());  // Ausgabedatei
{int i=0;                                   // Zählvariable Zeilen
    cout << "File found" << endl;           // Kontrollausgabe

//Einlesen der .txt
while(dateiLese.getline (zeile, 1024)){
    Seite[i]=zeile;

    //Schreiben der neuen Datei .ixm
    if (i==0){
        dateiSchreibe <<"[Execute]" << "\n";    //Nur erste Zeile schreiben
    }

    dateiSchreibe <<Seite[i] << "\n";           //Kopie der alten Datei zeilenweise

    i++;
}

dateiLese.close ();
dateiSchreibe.close();

}

}
else {
        cout<<"All Files Achived! - Nothing more to be done"<<endl;
    }
    Sleep(10000);
}
FindClose(fileHan);

return(0);

}//end main

if (filename == fileData.cFileName){
        break;
        }

brauchst du schon mal nicht. Werte stattdessen die Rückgabe von FindNextFile aus. So kannst du auch gleich eine sinnvolle Abbruchbedingung für deine innere while-Schleife definieren.

Zu deinem Problem: bist du schon mal schrittweise mit dem Debugger durch dein Programm gegangen? Ich vermute mal, du hast bislang keinen Debugger benutzt, richtig? Das ist der eigentliche Fehler! Setze einen Haltepunkt an einer günstigen Stelle und sieh dir dann genau an, was bei jedem Schritt passiert. Irgendwann erreichst du den Punkt, an dem nicht das passiert, was du eigentlich wolltest.

EDIT: Ähm, ich habe mir deinen Code jetzt doch mal angesehen (in meinem Editor, vernünftig eingerückt). Ist doch klar, dass nur die letzte Datei in neuer Version gespeichert wird. Deine Schleife mit FindNextFile wird zunächst abgearbeitet, bis alle txt-Dateien durch sind. Und im Anschluss hast du dann einfach das Schreiben daruntergeklatscht und verwendest dabei halt das letzte filename. Du solltest jedesmal beim Finden einer txt-Datei auch deinen Schreibkram ausführen. Und was soll eigentlich die Variable k? Die wird nie inkrementiert, somit ist deine äußere while-Schleife eine Endlosschleife...

Und was soll eigentlich die Variable k? Die wird nie inkrementiert, somit ist deine äußere while-Schleife eine Endlosschleife...

Das soll ja auch eine Endlosschleife sein, da das ganze alle 10Sekunden gemacht werden soll....

Wie könnte ich das besser lösen?

Ich habe es jetzt so gemacht, das ich die letzte Datei lösche, somit springt er zur nächsten...

Den Pfad wollte ich noch Variabel gestalten indem ich zunächste ein CIN mach um den Pfad einzulesen.

Er springt auch in den richtigen Ordner, macht dann aber nicht mehr weiter....

#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <string>
#include <iostream>
#include <fstream>
#include <dos.h>

using namespace std;

WIN32_FIND_DATA fileData;
HANDLE fileHan;

int main(){

//Einlesen des Pfades in Variable path
char path [300];
cout<<"Pfad eingeben - Statt '\\' MUSS '\\\\' verwendet werden (C:\\\\Dokumente\\\\*.txt)"<<endl;
cout<<"Pfad: ";
cin>>path;

//Schleife für ständige Wiederholung
char zeile [1024];
string Seite [100];

int k=0;
while(k< 2) {

string filename;

fileHan = FindFirstFile(path, &fileData);

while (true){
    FindNextFile(fileHan, &fileData);

    if (filename == fileData.cFileName){
        break;
        }

    filename = fileData.cFileName;

    if(fileHan == INVALID_HANDLE_VALUE){
        cout << "Process Failed"<<endl;
        }
        else {
            cout << "The first File found is " << filename<<endl;
            }

     }//end while

ifstream dateiLese((path + filename).c_str());
    if (dateiLese){                             // Wenn Datei vorhanden....
        ofstream dateiSchreibe ((path + filename+ ".ixm").c_str());  // Ausgabedatei
        {int i=0;                                   // Zählvariable Zeilen
            cout << "File found" << endl;           // Kontrollausgabe

//Einlesen der .txt
while(dateiLese.getline (zeile, 1024)){
    Seite[i]=zeile;

    //Schreiben der neuen Datei .ixm
    if (i==0){
        dateiSchreibe <<"[Execute]" << "\n";    //Nur erste Zeile schreiben
    }

    dateiSchreibe <<Seite[i] << "\n";           //Kopie der alten Datei zeilenweise

    i++;
    }

dateiLese.close ();
dateiSchreibe.close();

//rename(("C:\\Users\\Jonny\\Desktop\\SFStoINOX\\" + filename).c_str(), ("C:\\Users\\Jonny\\Desktop\\SFStoINOX\\" + filename+ ".done").c_str());
remove((path + filename).c_str());
    }//end if (dateiLese)

}
else {
        cout<<"All Files Achived! - Nothing more to be done"<<endl;
    }
    Sleep(10000);
}
FindClose(fileHan);

return(0);

}//end main

2. Deine neue Aufforderung zur Benutzereingabe ist so falsch. Der Benutzer muss ganz normal einen Backslash zum Trennen der Pfadelemente verwenden. Der einzige, der doppelte Backslashes notieren muss, bist du - und das auch nur, wenn du im Quellcode in Stringliteralen Backslashes schreiben willst. Dieser doppelte Backslash wird dann zu einem einfachen (siehe Escapesequenzen).

3. Das mit dem Löschen bringt dich auch irgendwie zur nächsten Datei, nett! Ist doch aber nicht, was du ursprünglich wolltest. Du willst doch einfach jede gefundene txt-Datei als ixm-Datei speichern, richtig? Und du findest in deiner ersten, inneren while-Schleife jede txt-Datei im Verzeichnis, richtig? Und du hast nach der Schleife einen Abschnitt, der die aktuell gefundene Datei als ixm-Datei speichert, richtig? Wo ist jetzt der Fehler? Genau, du musst diesen "ixm-Speicher-Abschnitt" einfach ans Ende deiner ersten, inneren while-Schleife packen. Sobald eine txt-Datei gefunden wurde, wird sie als ixm gespeichert. Und erst danach geht die Schleife in die nächste Runde und findet die nächste Datei, die dann wieder gespeichert wird usw.

#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <string>
#include <iostream>
#include <fstream>
#include <dos.h>

using namespace std;

WIN32_FIND_DATA fileData;
HANDLE fileHan;

int main(){

	char zeile [1024];
	string Seite [100];

	int k=0;
	while(k< 2) {

		string filename;

		fileHan = FindFirstFile("C:\\*.txt", &fileData);

		while (true){
			FindNextFile(fileHan, &fileData);

			if (filename == fileData.cFileName){
				break;
			}

			filename = fileData.cFileName;

			if(fileHan == INVALID_HANDLE_VALUE){
				cout << "Process Failed";
			}
			else {
				cout << "The first File found is " << filename<<endl;
			}

		}//end while

		/*ifstream fin(("C:\\" + filename).c_str());
		if(fin){
		cout<<"file found";

		}
		*/
		ifstream dateiLese(("C:\\" + filename).c_str());
		if (dateiLese){                             // Wenn Datei vorhanden....
			ofstream dateiSchreibe (("C:\\" + filename+ ".ixm").c_str());  // Ausgabedatei
			int i=0;                                   // Zählvariable Zeilen
			cout << "File found" << endl;           // Kontrollausgabe

			//Einlesen der .txt
			while(dateiLese.getline (zeile, 1024)){
				Seite[i]=zeile;

				//Schreiben der neuen Datei .ixm
				if (i==0){
					dateiSchreibe <<"[Execute]" << "\n";    //Nur erste Zeile schreiben
				}

				dateiSchreibe <<Seite[i] << "\n";           //Kopie der alten Datei zeilenweise

				i++;
			}

			dateiLese.close ();
			dateiSchreibe.close();
		}
		else {
			cout<<"All Files Achived! - Nothing more to be done"<<endl;
		}
		Sleep(10000);
	}
	FindClose(fileHan);

	return(0);

}//end main

Bemerkst du den Unterschied?

Das hier ist das erste C++ Prjekt das ich vin mir gebe und ich bin echt super froh hier gute Hilfe zu erhalten!!!

Ich bin hier gerade wild am verbessern;)

Aber ich habe es immer noch nicht geschafft den Pfad "Variabel" zu übergeben.

Ergeht zwar in den richtigen Ordner, stellt dann aber nix mehr an.

Hab ja da die Variable 'path' welche ich da übergeben will.

Das hier ist das erste C++ Prjekt das ich vin mir gebe und ich bin echt super froh hier gute Hilfe zu erhalten!!!

Ich bin hier gerade wild am verbessern;)

Nicht aufgeben, klappt bestimmt bald!

JonnyDaVinci schrieb:

Aber ich habe es immer noch nicht geschafft den Pfad "Variabel" zu übergeben.

Ergeht zwar in den richtigen Ordner, stellt dann aber nix mehr an.

Hab ja da die Variable 'path' welche ich da übergeben will.

Hab jetzt keine Zeit mehr, mir das genau anzusehen (vielleicht später heute Abend wieder). Aber eigentlich sehe ich da kein Problem, solange der Benutzer was Vernünftiges eingibt (z.B. "C:\*.txt"). Ich würde aber vorschlagen, dass du erstmal das Speichern aller Dateien umsetzt (falls nicht schon geschehen) und wir dann im Anschluss den variablen Pfad da reinbringen, ok? Übrigens: weißt du, dass du immer eine Datei überspringst? Du führst nämlich FindFirstFile aus und dann direkt im Anschluss FindNextFile. Somit machst du mit der zuerst gefundenen Datei gar nichts.

Ich habs nun soweit, dass der Pfad vom User eingegeben werden kann.
Nun möchte ich noch einen Schritt weiter gehen und dies über eine art .ini lösen.

Die soll so aussehen:

C:\a\b\c\
*.txt

Nun möchte ich diese Zeilenweise einlesen und in die Variablen speichern, welche ich zuvor manuell eingeben musste, sodass ich später nur noch bei Bedarf die .ini ändern muss.

Wie bekomme ich nun diese beide Zeilen in die Variablen?

Bisheriger Code:

#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <string>
#include <iostream>
#include <fstream>
#include <dos.h>

using namespace std;

WIN32_FIND_DATA fileData;
HANDLE fileHan;

int main(){

    //Einlesen des Pfades in Variable path     
    char path [1000];      //Variable für Pfad
    char data_end [6];      //Variable für Dateiendung
    char path_comp [1000];  //Pfad + Endung

//----------------------------------------------------------------------------------------
    //Eingabe des Pfades
    cout<<"Bitte Pfad eingeben"<<'\n';
    cout<<"Pfad: ";
    cin>>path;
    //cout<<path<<'\n';         //Testausgabe

    //Eingabe der Endung
    cout<<"Welche Endung hat die Datei? (Im Format '*.xxx' angeben)"<<'\n';
    cin>>data_end;

    //Kopieren und Zusammenfügen der Eingabe
    strcpy (path_comp, path);
    strcat (path_comp, data_end);
    puts(path_comp);
    //cout<<path_comp<<'\n';    //Testausgabe

//------------------------------------------------------------------------------------------
    //Schleife für ständige Wiederholung
    char zeile [1024];
    string Seite [100];

    //int k=0;
    while(true) {

//FindFile-----------------------------------------------------------------------------------
        string filename;

        fileHan = FindFirstFile(path_comp, &fileData);

            while (true){
                FindNextFile(fileHan, &fileData);

                if (filename == fileData.cFileName){
                    break;
                }

                filename = fileData.cFileName;

                if(fileHan == INVALID_HANDLE_VALUE){
                    cout << "Process Failed"<<'\n';
                }
                else {
                    cout << "The first File found is " << filename<<'\n';
                }

            }//end while FindFile

//OPEN--------------------------------------------------------------------------------------------------
        //Datei öffnen
        ifstream dateiLese((path+ filename).c_str());
        if (dateiLese){                                                     // Wenn Datei vorhanden....
            ofstream dateiSchreibe ((path + filename+ ".ixm").c_str());     // Ausgabedatei
        int i=0;                                                            // Zählvariable Zeilen
            cout << "File found" << '\n';                                   // Kontrollausgabe

//READ--------------------------------------------------------------------------------------------------
        //Einlesen der .txt
        while(dateiLese.getline (zeile, 1024)){
            Seite[i]=zeile;

//WRITE-------------------------------------------------------------------------------------------------
            //Schreiben der neuen Datei .ixm
            if (i==0){
                dateiSchreibe <<"[Execute]" << "\n";    //Nur erste Zeile schreiben
            }

            dateiSchreibe <<Seite[i] << "\n";           //Kopie der alten Datei zeilenweise

            i++;
        }                                               //end Einlesen

//CLOSE------------------------------------------------------------------------------------------------
            dateiLese.close ();
            dateiSchreibe.close();

            remove((path + filename).c_str());

        }

        else {
            cout<<"All Files Achived! - Nothing more to be done"<<endl;
        }
        Sleep(10000);
    }

    FindClose(fileHan);

    return(0);

}//end main

FRAGE: Wäre es besser mit Funktionen zu arbeiten?

JonnyDaVinci schrieb:

Ich habs nun soweit, dass der Pfad vom User eingegeben werden kann.
Nun möchte ich noch einen Schritt weiter gehen und dies über eine art .ini lösen.

Die soll so aussehen:

C:\a\b\c\
*.txt

Das ist keine ini-Datei. eine ini-Datei arbeitet mit Sektionen, Schlüsseln und Werten. Du hast hier nur Werte. Nenn es einfach Textdatei. Aber das nur am Rande...

JonnyDaVinci schrieb:

FRAGE: Wäre es besser mit Funktionen zu arbeiten?

Ja! Funktionen helfen, Funktionalität zu gliedern und Übersicht zu schaffen. Solltest du unbedingt machen. Einen Vorschlag habe ich schon:

SaveFileAsIXM(string sourceFilename, string path) {
  //...
}

So oder so ähnlich, je nachdem was du genau willst.

also das PRogramm macht im mom genau das was soll. Es liest die Datei, erweitert sie und speichert sie unter .ixm wieder ab. Danach löscht es die nicht mehr benötigte .txt. Vllt nicht so schön vom Code her, aber es funktioniert. Es wird auch keine Datei ausgelassen.;)

Es wird auch keine Datei ausgelassen.;)

Stimmt leider nicht. Ich habe unter C:\ eine Datei test.txt und eine test2.txt. Jetzt schau mal hier:

fileHan = FindFirstFile(path_comp, &fileData);  //in fileData steht nun die Datei test.txt

        while (true){
            FindNextFile(fileHan, &fileData);     //hier wird direkt auf die nächste Datei gesprungen. es steht nun also test2.txt in fileData. Mit test.txt wurde gar nichts gemacht.

Welche IDE benutzt du? Zufällig Visual Studio? Dann könnte ich dir nämlich mal sagen, wie ein paar grundlegende Debugging-Mechanismen funktionieren. Glaube mir, das würde dir ungemein helfen.

Also bei mir geht er alle Dateien durch!
Die erste zeigt er zwar zunächst nich in der Konsole an, bearbeitet diese aber zu schluss...

Z.B. test.txt
test2.txt

dann steht in der Konsole zuerst nur test2.txt. ja.
Beim nächsten durchgang jedoch wird auch die test.txt verarbeitet.

Sinnvoll wäre in etwa so ein Konstrukt:

while(true) {  //deine äußere Endlosschleife
  bool bFileFound=true;

  fileHan = FindFirstFile(path_comp, &fileData);
  if(fileHan==INVALID_HANDLE_VALUE) {  //wenn gar keine Dateien mit der Endung gefunden werden, muss die Schleife unten auch nicht ausgeführt werden
    bFileFound=false;
  }

  while(bFileFound) {  //solange Dateien gefunden werden, werden sie als ixm gespeichert

    //mache was mit der Datei (Speichern als ixm usw.)

    //hier erst die nächste Datei suchen; bei der nächsten Iteration wird sie dann verarbeitet
    if(FALSE==FindNextFile(fileHan, &fileData)) {
      bFileFound=false;  //wenn keine Datei mehr gefunden wird, wird hiermit die Schleife beendet
    }
  }
}

probier ich mal aus!

ich benutz Code::Blocks

Da kenne ich mich zwar nicht aus, aber hier ist doch ne schöne Übersicht:

http://wiki.codeblocks.org/index.php?title=Debugging_with_Code::Blocks

Schau dir vor allem mal "Set breakpoints" an.

Ganz kurz:

Ein Haltepunkt funktioniert folgendermaßen: Du setzt ihn an einer bestimmten Stelle (Zeile) des Programms. Dann startest du das Programm. Sobald die Ausführung an dieser Stelle angekommen ist, hält das Programm an! Du bist nun also im Quellcode, obwohl das Programm gerade läuft, und kannst Variableninhalte überprüfen und ändern, den Ausführungszeiger versetzen uvm. Wichtig ist auch, dass du von da aus schrittweise - also Zeile für Zeile - durch das Programm gehen kannst und somit genauestens den Ablauf überprüfen kannst (bei dir müsste F7 die nächste Zeile ausführen, probier es mal aus). Oft programmiert man sich Schleifen und Verzweigungen zusammen, die letztlich gar nicht das machen, was man selbst da sieht. Daher ist es ungemein wichtig, diesen Ablauf mal überprüfen zu können. Und dafür ist der Debugger da!

Schau ich mir auch ma an;)

Ich werd doch noch dieses Progrämmelchen fertig bekommen;)

Ich werd doch noch dieses Progrämmelchen fertig bekommen;)

Aber klar. Nur nie die Geduld verlieren (davon braucht man manchmal richtig viel), dann klappt das schon.