bytes auslesen

Hallo kann ich irgendwie die Bytes der Datei auslesen und diese dann in einer neuen Datei abspeichern so das ich z.b. Notepad unter dem neuen Datei namen starten kann ?

Hier ist einer meiner Versuche welche natürlich nicht funktionierten

#include <iostream>
#include <fstream>
using namespace std;

int main(int argc, char* argv[])
{
char buf;
ofstream datei("neu.exe",ios::app);
ifstream file;

             file.open("notepad.exe",ios::binary);

             while ( !file.eof() )
             { 
                     file >> buf;

                     datei<<buf;
             }
             file.close();

system("PAUSE");
}

Wofür will ich das machen ?

http://www.c-plusplus.net/forum/viewtopic-var-t-is-247902.html

Machst du so, guckstu du hier:

ofstream out ("test");
	out << "Puuuuuuuuuuuuuups!";
	out.close();
	system ("notepad test");

SeppJ

<< und >> sind für formatierte Ein-/Ausgabe. Bei Programmdateien ist es aber wichtig, dass das Format nicht geändert wird. Außerdem ist while(!file.eof()) keine gute Idee, weil du so noch einmal etwas falsches in die Ausgabe schreibst, nachdem das Dateiende erreicht ist.

get und put sind für unformatiertes Lesen/Schreiben. Und diese liefern schon als Returnwert, ob das Lesen erfolgreich war. Somit ist die funktionierende Variante folgendes:

while (file.get(buf)) datei.put(buf);

Dir ist aber doch wohl klar, dass du gerade das Rad zum x-ten Mal neu erfindest?

edit: Wenn du dich etwas fortgeschrittener fühlst, kannst du obiges auch nochmal um einiges eleganter mit Streamiteratoren schreiben, aber das überlasse ich mal dem geneigten Leser als Übung

Funktioniert ty :>

#include <iostream>
#include <fstream>
using namespace std;

int main(int argc, char* argv[])
{

char buf;
ifstream file;

ofstream datei("test.exe",ios::binary);
file.open("Project2.exe",ios::binary);

    while ( file.get(buf) )
    datei.put(buf);

    file.close();
    datei.close();

system("PAUSE");
}
//---------------------------------------------------------------------------

Mit iteratoren wollte ich mich sowieso mal bald beschäftigen. ^^

Aber wo genau ist der Vorteil ?

Meiner Meinung nach wäre der Vorteil das man doch da z.b. bei bestimmten Sachen auf Schleifen verzichten kann und so das Programm ja dann schneller ausgeführt wird.

Ich hatte letzdens mal eine Frage gestellt wie man Text Filtern kann.

Und da gab es dann eine Lösung mit iteratoren und eine ohne und die Lösung ohne iteratoren in der waren Schleifen enthalten.

SeppJ

Das Programm wird dadurch nicht schneller, es muss ja immer noch das gleiche geleistet werden. Die Schleifen sind dabei nur etwas versteckt.

Der große Vorteil ist, dass du mit Streamiteratoren die Lösung von Ein-/Ausgabeprobleme sehr allgemein formulieren kannst. Somit musst du im Prinzip nur einmal den nötigen Code in eine Funktion schreiben und musst dann nur ein wenig am Aufruf der Funktion ändern um ein völlig anderes Ein-/Ausgabeproblem zu lösen.

Wenn ich mal mehr Zeit habe, kann ich ja mal ein Beispiel bringen oder vielleicht hat jemand anderes gerade etwas parat?

Nexus

byte_leser schrieb:

Mit iteratoren wollte ich mich sowieso mal bald beschäftigen. ^^

Aber wo genau ist der Vorteil ?

Der Vorteil von Iteratoren besteht vor allem in der Abstraktion, die durch deren Verwendung erlangt wird. Nehmen wir an, du hast einen double -Container und willst alle seine Elemente um 1.5 erhöhen. Zum Beispiel einen std::vector . Ohne Iteratoren würdest du das wahrscheinlich so machen:

std::vector<double> MyDoubles; // füllen

for (size_t i = 0; i < MyDoubles.size(); ++i)
{
   MyDoubles[i] += 1.5;
}

Nun merkst du plötzlich, dass du sehr oft Elemente am Anfang einfügen willst und entscheidest dich, eine dafür geeignetere Datenstruktur zu wählen, zum Beispiel eine verkettete Liste. std::list besitzt aber keinen Random Access (Zugriff über Index), folglich musst du zu Iteratoren greifen. Also schreibst du:

for (std::list<double>::iterator iter = MyDoubles.begin(); iter != MyDoubles.end(); ++iter)
{
    (*iter) += 1.5;
}

Wenn du jetzt wieder merkst, dass std::vector trotzdem besser gewesen wäre, weil die Einfügungen durch eine sinnvollere Alternative ersetzt werden können, kannst du auch gleich Iteratoren für std::vector verwenden. Um dann nicht noch den Typ jedes Mal ändern zu müssen, verwendest du typedef .

typedef std::vector<double> DoubleContainer;

DoubleContainer MyDoubles;

for (DoubleContainer::iterator iter = MyDoubles.begin(); iter != MyDoubles.end(); ++iter)
{
    (*iter) += 1.5;
}

Damit bleibst du schön generisch. Dadurch, dass du die Schleife vom konkreten Containertyp unabhängig machst und den Typen in nur einer einzigen Zeile ändern kannst, erhältst du die erwähnte Abstraktion.

Das ist natürlich nur ein kleines Beispiel. Besonders im Zusammenhang mit den Algorithmen sind Iteratoren noch viel zentraler. Ich schlage dir vor, du liest dich in die STL-Artikel ein, besonders Teil 2 erklärt die hier angeschnittene Thematik (dafür ist aber Teil 1 als Grundlage erforderlich):
1) Container
2) Iteratoren und Algorithmen
3) Hilfsklassen und Erweiterungen

ty erst mal für die Infos.

Aber eine Frage hab ich noch.
Wie kann ich das machen wenn ich ein Array habe ?

Kann man

char buf[256];

irgendwie in ein normales char Konvertieren ?
Weil so funktioniert das ja nicht.

#include <iostream>
#include <fstream>
using namespace std;

int main()
{

char buf[256];

ifstream file;

ofstream datei("test.exe",ios::binary);
file.open("Notepad.exe",ios::binary);

    while ( file.get(buf) )
    {

            datei.put(buf);

    }

    file.close();
    datei.close();

    cout<<buf;

system("PAUSE");
}
//---------------------------------------------------------------------------

SeppJ

byte_leser schrieb:

Kann man
char buf[256];
irgendwie in ein normales char Konvertieren ?
Weil so funktioniert das ja nicht.

Wie soll das gehen? Du willst einen Korb Äpfel in einen Apfel umwandeln...
Du kannst aber natürlich einen einzelnen Apfel aus dem Korb nehmen, aber das solltest du wissen, wie das geht.

Ja das weiss ich wie das geht ich probiers mal morgen aus ty.

SeppJ

Das, was du da vorhast (meine Kristallkugel sagt mir, du willst den Lesepuffer vergrößern um weniger Schleifendurchgänge zu haben) bringt dir keinen Geschwindigkeitsvorteil. Die Streams sind gepuffert und dein Prozessor ist um Größenordnungen schneller als jeder Datenträger, selbst eine RAM-Disk kommt da nicht mit.