Binärdatei lesen und schreiben

Ich versuche, Code zu schreiben, um eine Binärdatei in einen Puffer zu lesen und dann den Puffer in eine andere Datei zu schreiben. Ich habe den folgenden Code, aber der Puffer speichert nur ein paar ASCII-Zeichen aus der ersten Zeile in der Datei und sonst nichts.

int length;
char * buffer;

ifstream is;
is.open ("C:\\Final.gif", ios::binary );
// get length of file:
is.seekg (0, ios::end);
length = is.tellg();
is.seekg (0, ios::beg);
// allocate memory:
buffer = new char [length];
// read data as a block:
is.read (buffer,length);
is.close();

FILE *pFile;
pFile = fopen ("C:\\myfile.gif", "w");
fwrite (buffer , 1 , sizeof(buffer) , pFile );

Wenn Sie dies auf C++-Weise tun möchten, gehen Sie folgendermaßen vor:

#include <fstream>
#include <iterator>
#include <algorithm>

int main()
{
    std::ifstream input( "C:\\Final.gif", std::ios::binary );
    std::ofstream output( "C:\\myfile.gif", std::ios::binary );

    std::copy( 
        std::istreambuf_iterator<char>(input), 
        std::istreambuf_iterator<char>( ),
        std::ostreambuf_iterator<char>(output));
}

Wenn Sie diese Daten in einem Puffer benötigen, um sie oder etwas anderes zu ändern, tun Sie dies:

#include <fstream>
#include <iterator>
#include <vector>

int main()
{
    std::ifstream input( "C:\\Final.gif", std::ios::binary );

    // copies all data into buffer
    std::vector<unsigned char> buffer(std::istreambuf_iterator<char>(input), {});

}

Hier ist ein kurzes Beispiel, das C++ verwendet rdbuf. Ich habe das aus dem Netz. Ich kann meine ursprüngliche Quelle dazu nicht finden:

#include <fstream>
#include <iostream>

int main () 
{
  std::ifstream f1 ("C:\\me.txt",std::fstream::binary);

  std::ofstream f2 ("C:\\me2.doc",std::fstream::trunc|std::fstream::binary);

  f2<<f1.rdbuf();

  return 0;
}

 sizeof(buffer) == sizeof(char*) 

Verwenden Sie stattdessen die Länge.

Auch besser zu bedienen fopen mit “wb“….

sizeof(buffer) ist die Größe eines Zeigers auf Ihrer letzten Zeile, NICHT die tatsächliche Größe des Puffers. Sie müssen stattdessen die bereits festgelegte “Länge” verwenden

Sie sollten length anstelle von sizeof(buffer) an fwrite übergeben.

Hier ist die Implementierung von Standard C++ 14 mit Vektoren und Tupel zum Lesen und Schreiben Text,Binary and Hex files.

Snippet-Code:

try {
if (file_type == BINARY_FILE) {

    /*Open the stream in binary mode.*/
    std::ifstream bin_file(file_name, std::ios::binary);

    if (bin_file.good()) {
        /*Read Binary data using streambuffer iterators.*/
        std::vector<uint8_t> v_buf((std::istreambuf_iterator<char>(bin_file)), (std::istreambuf_iterator<char>()));
        vec_buf = v_buf;
        bin_file.close();
    }

    else {
        throw std::exception();
    }

}

else if (file_type == ASCII_FILE) {

    /*Open the stream in default mode.*/
    std::ifstream ascii_file(file_name);
    string ascii_data;

    if (ascii_file.good()) {
        /*Read ASCII data using getline*/
        while (getline(ascii_file, ascii_data))
            str_buf += ascii_data + "\n";

        ascii_file.close();
    }
    else {
        throw std::exception();
    }
}

else if (file_type == HEX_FILE) {

    /*Open the stream in default mode.*/
    std::ifstream hex_file(file_name);

    if (hex_file.good()) {
        /*Read Hex data using streambuffer iterators.*/
        std::vector<char> h_buf((std::istreambuf_iterator<char>(hex_file)), (std::istreambuf_iterator<char>()));
        string hex_str_buf(h_buf.begin(), h_buf.end());
        hex_buf = hex_str_buf;

        hex_file.close();
    }
    else {
        throw std::exception();
    }
}

}

Vollständiger Quellcode kann gefunden werden Hier

Es gibt einen viel einfacheren Weg. Dabei spielt es keine Rolle, ob es sich um eine Binär- oder eine Textdatei handelt.

Verwenden Sie noskipws.

char buf[SZ];
ifstream f("file");
int i;
for(i=0; f >> noskipws >> buffer[i]; i++);
ofstream f2("writeto");
for(int j=0; j < i; j++) f2 << noskipws << buffer[j];

Oder Sie können anstelle des Puffers einfach eine Zeichenfolge verwenden.

string s; char c;
ifstream f("image.jpg");
while(f >> noskipws >> c) s += c;
ofstream f2("copy.jpg");
f2 << s;

normalerweise überspringt stream Leerzeichen wie Leerzeichen oder Zeilenumbrüche, Tabulatoren und alle anderen Steuerzeichen. Aber noskipws macht alle Zeichen übertragen. Dies kopiert also nicht nur eine Textdatei, sondern auch eine Binärdatei. Und Stream verwendet intern Puffer, ich gehe davon aus, dass die Geschwindigkeit nicht langsam sein wird.