On 31 Mar, 16:38, Victor Bazarov <v.Abaza...@comAcast.net> wrote:
tirzan wrote:
I would like to copy a the last part of a (quite big) file
into another one (remove the header of few big images,
basically remove the first 1024 bytes).
I'm driving crazy, can you please help me?
Will try...
This one of the attempts (but it just copies the file, how
can I tell to start copying from a certain position?):
std::fstream f(inputFileName, std::fstream::in|
std::fstream::binary);
Try to avoid one-letter variables. Hard to understand what
they are for when looking at them later in the code.
Hard to read them sometimes as well.
std::istream_iterator<unsigned char> begin(f.seekg(1024,
std::ios::beg));
'fstream' is of type 'basic_fstream<char>'. Do you really want to
change the type to 'unsigned char' here? You'd be better off using the
same template argument, no? How does it compile, anyway?
There's no real reason for the template arguments to be
identical here. They represent entirely different things. (The
second template argument of the istream_iterator should be the
same as that of the string, but it defaults to char, so it is.)
And, 'seekg' returns the stream. You're constructing an
iterator from the stream. Are you sure your iterator isn't
going to reset the stream?
That's not part of the behavior specified by the standard for
the constructor of the iterator.
Why don't you just do
std::istream_iterator<char> begin(f);
std::advance(begin, 1024); // skip the first 1024 bytes
Because it could be significantly slower. (For 1024 characters,
I doubt it, but for larger differences, advancing an
istream_iterator means reading that many elements.)
f << std::noskipws;
Now, what does that do for a *binary* input file?
The same thing as it does for a text input file. It means that
the initial skip of white space in the << operator won't take
place.
std::istream_iterator<unsigned char> end;
Again, use <char> .
Not if he's reading unsigned char.
std::fstream f2(outputFileName, std::fstream::out|
std::fstream::trunc| std::fstream::binary);
std::ostream_iterator<char> begin2(f2);
std::copy(begin, end, begin2);
So, to summarize: be simpler and more explicit.
He can't be much simpler. I'd rather he be a little more
explicit, however. Say by checking the status of the stream
after the seek, before copying the rest.
And post the final (hopefully short) program. We could try it
with a file longer than 1024 characters.
At first view, his code should work. I'd still like to see the
status of the input file after the seek, however.
After opening the two files and the seek, I'd probably just
write:
f2 << f.rdbuf();
rather than bother with std::copy.
Thank you for your comments. As always very informative. As for using
operators on what is intended as a straight copy. Do you think that