Reading and writing binary file

I'm trying to write code to read a binary file into a buffer, then write the buffer to another file. I have the following code, but the buffer only stores a couple of ASCII characters from the first line in the file and nothing else.

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 );

If you want to do this the C++ way, do it like this:

#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));
}

If you need that data in a buffer to modify it or something, do this:

#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), {});

}

Here is a short example, the C++ way using rdbuf. I got this from the web. I can't find my original source on this:

#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*) 

Use length instead.

Also, better to use fopen with "wb"....

sizeof(buffer) is the size of a pointer on your last line NOT the actual size of the buffer. You need to use "length" that you already established instead

You should pass length into fwrite instead of sizeof(buffer).

Here is implementation of standard C++ 14 using vectors and tuples to Read and Write 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();
	}
}

}

Full Source code can be found here

There is a much simpler way. This does not care if it is binary or text file.

Use 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];

Or you can just use string instead of the buffer.

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

normally stream skips white space characters like space or new line, tab and all other control characters. But noskipws makes all the characters transferred. So this will not only copy a text file but also a binary file. And stream uses buffer internally, I assume the speed won't be slow.

It can be done with simple commands in the following snippet.

Copies the whole file of any size. No size constraint!

Just use this. Tested And Working!!

#include<iostream>
#include<fstream>
using namespace std;
int main()
{
  ifstream infile;
  infile.open("source.pdf",ios::binary|ios::in);

  ofstream outfile;
  outfile.open("temppdf.pdf",ios::binary|ios::out);

  int buffer[2];
  while(infile.read((char *)&buffer,sizeof(buffer)))
  {
	  outfile.write((char *)&buffer,sizeof(buffer));
  }

  infile.close();
  outfile.close();
  return 0;
}

Having a smaller buffer size would be helpful in copying tiny files. Even "char buffer[2]" would do the job.