What is the fastest way of copying files

[utab]

Hi there,

I am copying one file into another file character by character.

I wanted to learn if there is a faster way of doing this?

When files get bigger, maybe this can take a lot of time.

Thanks for the replies in advance.

[Ivan Vecerina]

"utab" <um********@gma il.com> wrote in message
news:11******** **************@ z34g2000cwc.goo glegroups.com.. .
: Hi there,
:
: I am copying one file into another file character by character.
:
: I wanted to learn if there is a faster way of doing this?
:
: When files get bigger, maybe this can take a lot of time.
:
: Thanks for the replies in advance.

For C++ streams, the easy way to copy one stream to another
is to send the source's streambuf to the output:
// #include <fstream>
std::ifstream src("source.txt ");
std::ofstream dst("destinatio n.txt");
dst << src.rdbuf();

This should perform faster than a character-by-character copy,
but actual performance is implementation-dependent.

Of course there is always a faster/more complicated/less portable
way to implement this operation.

hth -Ivan
--
http://ivan.vecerina.com/contact/?subject=NG_POST <- email contact form
Brainbench MVP for C++ <> http://www.brainbench.com

[Dietmar Kuehl]

Ivan Vecerina wrote:

For C++ streams, the easy way to copy one stream to another
is to send the source's streambuf to the output:
// #include <fstream>
std::ifstream src("source.txt ");
std::ofstream dst("destinatio n.txt");
dst << src.rdbuf();

I think the more expressive formulation of the last line is

std::copy(std:: istreambuf_iter ator<char>(src) ,
std::istreambuf _iterator<char> (),
std::ostreambuf _iterator<char> (dst));

However, to get this as efficient as the other version is non-trivial
and effectively requires optimized algorithms for the segmented
sequences.
--
<mailto:di***** ******@yahoo.co m> <http://www.dietmar-kuehl.de/>
<http://www.eai-systems.com> - Efficient Artificial Intelligence

[Gernot Frisch]

However, to get this as efficient as the other version is
non-trivial
and effectively requires optimized algorithms for the segmented
sequences.

Hint: On some compilers the fstream classes are horribly slow in
comparison to fopen/fread/fwrite. For large files you should check if
you can speed up with these.
Also, copyiny byte by byte is generally a bad idea. Read to a buffer
(e.g. 4096 bytes) and write this.

[Dietmar Kuehl]

Gernot Frisch wrote:

However, to get this as efficient as the other version is
non-trivial
and effectively requires optimized algorithms for the segmented
sequences.

Hint: On some compilers the fstream classes are horribly slow in
comparison to fopen/fread/fwrite. For large files you should check if
you can speed up with these.
Also, copyiny byte by byte is generally a bad idea. Read to a buffer
(e.g. 4096 bytes) and write this.

Another hint: my own implementation of IOStreams and 'std::copy()'
in particular *is* optimized to implement the algorithm use I have
shown in this thread in a form which is really fast. It is definitely
on par with any other approach you can use on the basis of the
standard C or C++ libraries.
--
<mailto:di***** ******@yahoo.co m> <http://www.dietmar-kuehl.de/>
<http://www.eai-systems.com> - Efficient Artificial Intelligence

[Alex Vinokur]

utab wrote:

Hi there,

I am copying one file into another file character by character.

I wanted to learn if there is a faster way of doing this?

When files get bigger, maybe this can take a lot of time.

Thanks for the replies in advance.

Look at Simple C/C++ Perfometer: Copying Files (Versions 4.x)
http://groups.google.com/group/perfo...74465da4c4e9bb

Alex Vinokur
email: alex DOT vinokur AT gmail DOT com
http://mathforum.org/library/view/10978.html
http://sourceforge.net/users/alexvn

[dan2online]

Think about block-copy, not character.

[noone]

On Thu, 13 Apr 2006 22:03:40 -0700, Alex Vinokur wrote:

utab wrote:

Hi there,

I am copying one file into another file character by character.

I wanted to learn if there is a faster way of doing this?

When files get bigger, maybe this can take a lot of time.

Thanks for the replies in advance.

If you care to use platform dependent functions then you can use memory
mapped file access. mmap() under unix maps a file to memory or a memory
region back to a file and does it much faster than userland character or
block copies.

To maintain portability you are generally limited to the stdlib routines
though.

[Ni]

Copying files using block's size equal to the filesystem's scluster
size is possibly is the fastest method.
Or you may try multithreading wih block copying method.