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

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

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

#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.

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?

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

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");
}
//---------------------------------------------------------------------------

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.