Datei binär kopieren

*-BootLag-*

Hallo liebe Forengemeinde,

ich habe ein kleines Problem.
Ich möchte eine Datei(.exe) binär blockweise(1024) einlesen und dann kopieren. Ich habe schon alle Varianten ausprobiert.
Hier mal eine etwas ältere Variante:

FILE *fr = fopen("assd.exe", "rb");
FILE *fw = fopen("asd.exe", "wb");

   while(size > 0)
   {
	char buffer[1030];
        if(size>=1024)
	{
		fread(buffer, 1024, 1, fr);
                fwrite(buffer, 1024, 1, fw);
	}
	else
	{
		fread(buffer, size, 1, fr);
		buffer[size]='\0';
		fwrite(buffer, size, 1, fw);
	}
	size -= 1024;
   }
fclose(fr);
fclose(fw);

Die kopierte exe ist dann immer um ca 20% kleiner als das Original und ich kann den Fehler nicht finden.

Als ich mir das ganze einmal zeichenweise ausgeben lassen habe, musste ich feststellen, dass ein Enter im ASCII Code als 2 bzw. 3Zeichen gewertet wurde. Zuerst sprang er an den Anfang der Zeile, dann eine Zeile tiefer und dann kam erst das nächste Zeichen. Vllt. hat das was damit zu tun...

Danke schonmal im v*******

Beschäftige dich etwas mit std::ofstream

std::ofstream outputFile( DATEINAME_HIER, std::ios::out|std::ios::binary);
outputFile.write( EINEN BUFFER, GRÖßE );
outputFile.close();

*-BootLag-*

genau das habe ich ja auch schon gemacht...da kommt dieselbe Anzahl an zu kopierenden Zeichen raus und derselbe Fehler! Ich finde nur keinen richtigen Grund wieso die kopierte Datei einfach geschrumpft ist und deshalb kaputt....

???

std::ifstream file ("C:\Bla.exe", std::ios::in|std::ios::binary)

if(!file)
{
std::cout<<"Fehler";
return 1;
}

file.read(buffer, Size)
file.close();

std::ofstream outputFile( "Bla.exe", std::ios::out|std::ios::binary);

if(!file)
{
std::cout<<"Fehler";
return 1;
}
outputFile.write(buffer, Size);
outputFile.close();

Belli

Oder, falls Du lieber bei C bleiben möchtest:

#include <stdio.h>

int main()
{
	FILE *fr = fopen("assd.exe", "rb");
	FILE *fw = fopen("asd.exe", "wb");

	char buffer[1024];

	size_t gelesen = fread(buffer, 1, 1024, fr);

	while(gelesen)
	{
		fwrite(buffer, 1, gelesen, fw);
		gelesen = fread(buffer, 1, 1024, fr);
	}

	fclose(fr);
	fclose(fw);
}

*-BootLag-*

Danke für eure Hilfen...
Habs jetzt so gelöst:

#include <iostream>
#include <fstream>

using namespace std;

int main()
{
    filebuf file_in;
    file_in.open("asd.exe", ios::in | ios::binary);
    filebuf file_out;
    file_out.open("assd.exe", ios::out | ios::binary);

    char buffer[1024];

    int gelesen = file_in.sgetn(buffer, 1024);
    while(gelesen)
    {
        file_out.sputn(buffer, 1024);
        gelesen = file_in.sgetn(buffer, 1024);
    }

    file_in.close();
    file_out.close();
}

Belli

Da wird Deine Zieldatei aber häufig größer sein, als die Quelldatei ...

*-BootLag-*

Wieso? Habe das ganze in eine Server-Client-Anwendung eingebunden und mal ne Datei versendet...Beide Dateien haben dieselbe Anzahl an Bytes...funzt prima... .exe Dateien lassen sich nach dem versenden immernoch problemlos ausführen :xmas2:

Belli

Weil Du:

file_out.sputn(buffer, 1024);

IMMER 1024 Byte schreibst. Wenn die Größe Deiner Quelldatei nicht zufällig ein Vielfaches von 1024 Byte ist, liest Du beim letzten Schleifendurchlauf weniger, als Du dann schreibst.

*-BootLag-*

Ehm die benutzten Lese-und Schreibfunktionen lesen soviel ein, wie da ist. Deshalb übernehme ich doch immer den Rückgabetyp, der die gelesenen Zeichen angibt und nur die werden gesendet/geschrieben...
Mhh ich überprüf das nochmal kurz^^

*-BootLag-*

SO nochmal getestet mit einer nicht durch 1024 teilbaren Größe...
Klappt auch wunderbar. Ich sehe da keinen Fehler.

Edit:

Ah jetzt weiß ich was du bemängelst XD Wie dumm von mir... Ich habe den obigen Quelltext noch ein wenig modifiziert^^ Es werden nur soviele Bytes geschrieben/versendet, wie zuvor gelesen wurden...Damit ist alles geklärt und alle sind zufrieden