关于c ++：以合理，安全，有效的方式复制文件

Copy a file in a sane, safe and efficient way

我寻找一种复制文件(二进制或文本)的好方法。我写了几个样品，每个人都在工作。但我想听听经验丰富的程序员的意见。

我错过了很好的例子，并寻找一种方式与C++工作。

ANSI-C-WAY

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#include <iostream>
#include <cstdio> // fopen, fclose, fread, fwrite, BUFSIZ
#include <ctime>
using namespace std;

int main() {
clock_t start, end;
start = clock();

// BUFSIZE default is 8192 bytes
// BUFSIZE of 1 means one chareter at time
// good values should fit to blocksize, like 1024 or 4096
// higher values reduce number of system calls
// size_t BUFFER_SIZE = 4096;

char buf[BUFSIZ];
size_t size;

FILE* source = fopen("from.ogv","rb");
FILE* dest = fopen("to.ogv","wb");

// clean and more secure
// feof(FILE* stream) returns non-zero if the end of file indicator for stream is set

while (size = fread(buf, 1, BUFSIZ, source)) {
fwrite(buf, 1, size, dest);
}

fclose(source);
fclose(dest);

end = clock();

cout <<"CLOCKS_PER_SEC" << CLOCKS_PER_SEC <<"
";
cout <<"CPU-TIME START" << start <<"
";
cout <<"CPU-TIME END" << end <<"
";
cout <<"CPU-TIME END - START" << end - start <<"
";
cout <<"TIME(SEC)" << static_cast<double>(end - start) / CLOCKS_PER_SEC <<"
";

return 0;
}

posix-way(k&r在"C编程语言"中使用它，更低级)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include <iostream>
#include <fcntl.h> // open
#include <unistd.h> // read, write, close
#include <cstdio> // BUFSIZ
#include <ctime>
using namespace std;

int main() {
clock_t start, end;
start = clock();

// BUFSIZE defaults to 8192
// BUFSIZE of 1 means one chareter at time
// good values should fit to blocksize, like 1024 or 4096
// higher values reduce number of system calls
// size_t BUFFER_SIZE = 4096;

char buf[BUFSIZ];
size_t size;

int source = open("from.ogv", O_RDONLY, 0);
int dest = open("to.ogv", O_WRONLY | O_CREAT /*| O_TRUNC/**/, 0644);

while ((size = read(source, buf, BUFSIZ)) > 0) {
write(dest, buf, size);
}

close(source);
close(dest);

end = clock();

cout <<"CLOCKS_PER_SEC" << CLOCKS_PER_SEC <<"
";
cout <<"CPU-TIME START" << start <<"
";
cout <<"CPU-TIME END" << end <<"
";
cout <<"CPU-TIME END - START" << end - start <<"
";
cout <<"TIME(SEC)" << static_cast<double>(end - start) / CLOCKS_PER_SEC <<"
";

return 0;
}

KISS-C++-流缓冲方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <iostream>
#include <fstream>
#include <ctime>
using namespace std;

int main() {
clock_t start, end;
start = clock();

ifstream source("from.ogv", ios::binary);
ofstream dest("to.ogv", ios::binary);

dest << source.rdbuf();

source.close();
dest.close();

end = clock();

cout <<"CLOCKS_PER_SEC" << CLOCKS_PER_SEC <<"
";
cout <<"CPU-TIME START" << start <<"
";
cout <<"CPU-TIME END" << end <<"
";
cout <<"CPU-TIME END - START" << end - start <<"
";
cout <<"TIME(SEC)" << static_cast<double>(end - start) / CLOCKS_PER_SEC <<"
";

return 0;
}

copy-algorithm-c++-方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#include <iostream>
#include <fstream>
#include <ctime>
#include
#include <iterator>
using namespace std;

int main() {
clock_t start, end;
start = clock();

ifstream source("from.ogv", ios::binary);
ofstream dest("to.ogv", ios::binary);

istreambuf_iterator<char> begin_source(source);
istreambuf_iterator<char> end_source;
ostreambuf_iterator<char> begin_dest(dest);
copy(begin_source, end_source, begin_dest);

source.close();
dest.close();

end = clock();

cout <<"CLOCKS_PER_SEC" << CLOCKS_PER_SEC <<"
";
cout <<"CPU-TIME START" << start <<"
";
cout <<"CPU-TIME END" << end <<"
";
cout <<"CPU-TIME END - START" << end - start <<"
";
cout <<"TIME(SEC)" << static_cast<double>(end - start) / CLOCKS_PER_SEC <<"
";

return 0;
}

own-buffer-c++-路

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#include <iostream>
#include <fstream>
#include <ctime>
using namespace std;

int main() {
clock_t start, end;
start = clock();

ifstream source("from.ogv", ios::binary);
ofstream dest("to.ogv", ios::binary);

// file size
source.seekg(0, ios::end);
ifstream::pos_type size = source.tellg();
source.seekg(0);
// allocate memory for buffer
char* buffer = new char[size];

// copy file
source.read(buffer, size);
dest.write(buffer, size);

// clean up
delete[] buffer;
source.close();
dest.close();

end = clock();

cout <<"CLOCKS_PER_SEC" << CLOCKS_PER_SEC <<"
";
cout <<"CPU-TIME START" << start <<"
";
cout <<"CPU-TIME END" << end <<"
";
cout <<"CPU-TIME END - START" << end - start <<"
";
cout <<"TIME(SEC)" << static_cast<double>(end - start) / CLOCKS_PER_SEC <<"
";

return 0;
}

linux-way//需要内核>=2.6.33

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <iostream>
#include <sys/sendfile.h> // sendfile
#include <fcntl.h> // open
#include <unistd.h> // close
#include <sys/stat.h> // fstat
#include <sys/types.h> // fstat
#include <ctime>
using namespace std;

int main() {
clock_t start, end;
start = clock();

int source = open("from.ogv", O_RDONLY, 0);
int dest = open("to.ogv", O_WRONLY | O_CREAT /*| O_TRUNC/**/, 0644);

// struct required, rationale: function stat() exists also
struct stat stat_source;
fstat(source, &stat_source);

sendfile(dest, source, 0, stat_source.st_size);

close(source);
close(dest);

end = clock();

cout <<"CLOCKS_PER_SEC" << CLOCKS_PER_SEC <<"
";
cout <<"CPU-TIME START" << start <<"
";
cout <<"CPU-TIME END" << end <<"
";
cout <<"CPU-TIME END - START" << end - start <<"
";
cout <<"TIME(SEC)" << static_cast<double>(end - start) / CLOCKS_PER_SEC <<"
";

return 0;
}

环境

GNU/Linux(ArchLinux)
内核3.3
glibc-2.15，libstdc++4.7(gcc-libs)，gcc 4.7，coreutils 8.16
使用运行级别3(多用户、网络、终端、无GUI)
Intel SSD Postville 80 GB，已满50%
复制一个270 MB的ogg-video-file

复制的步骤

1
2
3
4
5
6

1. $ rm from.ogg
2. $ reboot # kernel and filesystem buffers are in regular
3. $ (time ./program) &>> report.txt # executes program, redirects output of program and append to file
4. $ sha256sum *.ogv # checksum
5. $ rm to.ogg # remove copy, but no sync, kernel and fileystem buffers are used
6. $ (time ./program) &>> report.txt # executes program, redirects output of program and append to file

结果(使用的CPU时间)

1
2
3
4
5
6
7

文件大小不变。sha256sum打印相同的结果。视频文件仍然可以播放。

问题

你喜欢什么方法？
你知道更好的解决方案吗？
你看到我的代码有错误吗？
你知道避免解决方案的原因吗？
fstream(吻，streambuffer)我真的很喜欢这个，因为它很短很简单。据我所知，rdbuf()的操作符<<被重载，并且不转换任何内容。对的？

谢谢

更新1我以这种方式更改了所有样本的源代码，即文件描述符的打开和关闭都包含在clock()的度量中。它们不是源代码中的其他重要更改。结果没有改变！我也用时间来复查我的结果。

更新2ANSIC示例已更改：while循环的条件不再调用feof()，而是将fread()移到条件中。看起来，代码现在运行速度快了10000个时钟。

测量结果发生了变化：以前的结果总是得到缓冲，因为我对每个程序重复了几次旧的命令行rm to.ogv&；sync&；time./程序。现在我为每个程序重新启动系统。未缓冲的结果是新的，并不令人惊讶。未缓冲的结果并没有真正改变。

如果我不删除旧的拷贝，程序的反应就不同了。使用posix和sendfile覆盖现有的缓冲文件更快，所有其他程序都较慢。可能选项truncate或create会影响此行为。但是用相同的副本覆盖现有的文件并不是一个真实的用例。

用cp执行复制需要0.44秒的无缓冲时间和0.30秒的缓冲时间。所以cp比posix示例慢一点。我看起来不错。

也许我还添加了来自boost:：filesystem的mmap()和copy_file()的示例和结果。

更新3我也把它放在了一个博客页面上，并扩展了一点。包括splice()，它是Linux内核中的一个低级函数。也许会有更多的Java样本。http://www.ttyhoney.com/blog/？PaGyId＝69

相关讨论

fstream对于文件操作无疑是一个很好的选择。
richelbilderbeek.nl/cppcopy_file.htm文件
你忘记了懒惰的方式：系统("cp-from.ogv to.ogv")；
我不喜欢这种懒惰的方式。所以我才不提。它很难看。另一方面，coreutils中的代码经过了长期的测试和验证。
#include copyfile(const char *from, const char *to, copyfile_state_t state, copyfile_flags_t flags);
为什么你只花时间来复制文件，而不是打开/关闭时间？如果您正在进行多次迭代，那么每次复制某些内容时的启动/关闭时间可能会非常重要。
你说得对，凯文。我用这种方式更新了样本。我之前的意图是，用户已经访问了"文件"，并且只监视复制进度本身。但是文件描述符的打开/关闭是复制进度的一部分！
我想说使用boost::filesystem::copy_file。
请你把计时结果的"单位"修正一下好吗？"每秒时钟"毫无意义，这是处理器时钟速度的度量，与I/O无关。您的意思是"每个文件的时钟"？
我把描述改为"CPU时间"，通常也指"CPU计时"。这与clock()的手册页的描述匹配。更好？
就我个人而言，只有在为每个示例添加错误处理并比较添加的代码之后，我才会做出决定：在决定要做什么时，直接的性能显然是一个很大的因素，但它通常不应该是唯一的因素。
博客页面已不存在。你的文章还在某处吗？
目前没有。我将在接下来的几周内重新建立这个博客。
如果source为空，那么写入它的rdbuf将导致在目标流上设置failbit。出于这个原因，您可能更喜欢STD：：复制为默认C++可移植的方法(如果您打算将其他内容写入目的流)。
很抱歉这么晚才插嘴，但我认为这些都不是"安全的"，因为它们没有任何错误处理。
sendfile示例错误。sendfile宣布为ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);。注意第三个论点是off_t *offset。因此，sendfile(dest, source, 0, stat_source.st_size);可能导致SIGSEGV。
@Andrewhenle:很抱歉，但是手册页上说它可以通过[0 null nullptr]并且sendfile将从偏移位置开始(本例中是文件的开头)。
@彼得·埃多克斯(Peter EDOCX1)(9)在基于观点的方向上回答了这个问题，因为偏好和定义不明确的"更好"是主观的(你的意思是"更快"？).诸如"还有其他方法吗？他们的优点和缺点是什么？"(就像你的Do you know a reason to avoid a solution?一样)更适合这样做。
@凯思：老实说，你的建议听起来很理论化，改变这个词并不能改善什么。因为我不再维护我的博客，并且示例列表中缺少splice()(这很好)，所以我希望添加splice()并尝试将这一完整的内容合并到新的文档站点，我认为这将是一个很好的方法。请容忍我：)
@彼得理论如何？也许你没有理解我的观点；我是说你问的是基于观点的问题，这是堆栈溢出的主题之外的问题。目前的答案不是意见，因此只删除这两个问题就可以改善这个问题。
测量I/O绑定操作的CPU时间是没有意义的。唯一感兴趣的时间是挂钟经过的时间。
发送文件示例将在大于2GB的文件上失败

以正常方式复制文件：

1
2
3
4
5
6
7
8
9

#include <fstream>

int main()
{
std::ifstream src("from.ogv", std::ios::binary);
std::ofstream dst("to.ogv", std::ios::binary);

dst << src.rdbuf();
}

这是如此简单和直观的阅读它是值得额外的费用。如果我们经常这样做，最好还是回到对文件系统的操作系统调用上。我确信boost在其文件系统类中有一个copy-file方法。

有一种与文件系统交互的C方法：

1
2
3
4

#include <copyfile.h>

int
copyfile(const char *from, const char *to, copyfile_state_t state, copyfile_flags_t flags);

相关讨论

这是他的吻流缓冲C++方式。对于C++程序员来说，这是最自然的方式(尽管使用EDCOX1，0)也是非常地道的。既然这两种惯用方法恰好也是最快的便携方法…
copyfile不可移植；我认为它是Mac OS X特有的。它当然不存在于Linux上。boost::filesystem::copy_file可能是通过本机文件系统复制文件的最可移植方式。
@mikeseymur:copyfile()似乎是BSD扩展名。
看来洛基是对的。函数copyfile()似乎是*bsd和mac os的扩展名。
@彼得：我不会说Mac OS。Mac OS是一种BSD实现。
我只是小心而已。我知道有些人不想称Mac OS为Unix。
对于二进制文件，运算符"<<"是否正确？
@ Vincent：是的。参见：stackoverflow.com/questions/127666636/&hellip；
在Windows上正确地复制一个文件是非常困难的，除非你通过说copyfile把整个事情委托给Windows。
注意，在v 1.40.0中，boost copy_文件不能正常工作。
EDOCX1？4？
@Duedl0r:没有。对象有析构函数。流的析构函数自动调用Close()。codereview.stackexchange.com/q/540/507
@是的，如果超出范围。
DuelL0R：是的。但这就像是说"如果太阳下山"。你可以向西跑得很快，你可以让一天稍微长一点，但太阳要下山了。除非您有bug和泄漏内存(它将超出范围)。但是因为这里没有动态内存管理，所以不会有泄漏，而且它们将超出范围(就像太阳下山一样)。
@Lokiastari，这很好，尽管我刚刚发现std:：ios:：binary对于在Windows上正确复制文件是必需的。
有没有同样简单的复制权限的方法？
@曼格尔多夫：不是在语言层面上。语言没有"文件系统"的概念，更不用说权限了。您将需要使用操作系统或"文件系统"特定的API来实现这一点。
洛基，你知道一种处理POSIX权限的C++方法是否比FCHWON/FSTAT(例如StActPox.COM/A／5486922/148668)更能处理POSIX权限？
@ MnDeLoRF：不，因为C++没有文件系统的概念。为此，你必须使用图书馆。您使用的库将取决于您使用的系统(除非您使用lib来抽象文件系统(如boost:：file system))。
@Lokiastari：尽管有"日落"类比的所有吸引力，一个函数可能希望复制一个文件，然后开始执行一些耗时的任务——最极端的例子是：在进入守护进程/服务器模式之前，在main()上复制一个文件。不过-如何/何时处理这一问题显然会被提出问题的人很好地理解。
然后简单地将其包装在范围块中
别忘了给#include 。
@ AleCracbOsC++ 17具有EDOCX1，7。
@女侍：不需要。C++标准说，如果main函数不以返回结束，那么编译器将为您移植EDCOX1 8。此外，对于其他开发人员来说，通常做法是省略返回，作为应用程序不会失败的指示(即始终将成功状态代码返回给操作系统)。

用C++ 17，复制文件的标准方法将包括EDCOX1×7×标题和使用：

1
2
3
4
5
6

bool copy_file( const std::filesystem::path& from,
const std::filesystem::path& to);

bool copy_file( const std::filesystem::path& from,
const std::filesystem::path& to,
std::filesystem::copy_options options);

第一种形式相当于第二种形式，其中copy_options::none用作选项(另见copy_file)。

EDOCX1×10库最初被开发为EDCOX1×11，最终合并到C++ 17的ISO C++中。

相关讨论

太多了！

"ansi c"方式缓冲区是冗余的，因为已经缓冲了FILE。(此内部缓冲区的大小是BUFSIZ实际定义的。)

当"own-buffer-c++"通过执行大量虚拟调度的fstream时，它将变慢，并再次维护内部缓冲区或每个流对象。(由于streambuf_iterator类绕过流层，"copy-algorithm-c++-way"不受此影响。)

我更喜欢"copy-algorithm-c++-way"，但是在不构建fstream的情况下，只需在不需要实际格式化的情况下创建裸露的std::filebuf实例即可。

对于原始性能，不能超过POSIX文件描述符。它很难看，但便携，在任何平台上都很快。

Linux方式看起来非常快——也许操作系统会在I/O完成之前让函数返回？在任何情况下，对于许多应用程序来说，这都是不可移植的。

编辑：啊，"本机Linux"可能通过使用异步I/O交错读写来提高性能。让命令堆积起来可以帮助磁盘驱动程序决定什么时候是最佳搜索方式。您可以尝试增强asio或pthreads进行比较。至于"不能打败posix文件描述符"…如果你对数据做了任何事情，而不仅仅是盲目复制，那是真的。

相关讨论

我要特别指出的是，使用sendfile()的Linux方法存在一个主要问题，即它无法复制大小超过2GB的文件！我按照这个问题实现了它，并且遇到了问题，因为我使用它来复制大小为许多GB的HDF5文件。

http://man7.org/linux/man-pages/man2/sendfile.2.html

sendfile() will transfer at most 0x7ffff000 (2,147,479,552) bytes,
returning the number of bytes actually transferred. (This is true on
both 32-bit and 64-bit systems.)

相关讨论

qt有一种复制文件的方法：

1 2	#include <QFile> QFile::copy("originalFile.example","copiedFile.example");

请注意，要使用它，您必须安装qt(此处的说明)并将其包含在项目中(如果您使用的是Windows，而不是管理员，则可以在此处下载qt)。也可以看到这个答案。

相关讨论

对于喜欢Boost的人：

1
2
3
4
5
6
7
8

boost::filesystem::path mySourcePath("foo.bar");
boost::filesystem::path myTargetPath("bar.foo");

// Variant 1: Overwrite existing
boost::filesystem::copy_file(mySourcePath, myTargetPath, boost::filesystem::copy_option::overwrite_if_exists);

// Variant 2: Fail if exists
boost::filesystem::copy_file(mySourcePath, myTargetPath, boost::filesystem::copy_option::fail_if_exists);

请注意，boost：：filesystem：：path也可用作unicode的wpath。你也可以用

1	using namespace boost::filesystem

如果你不喜欢那些长字体的名字

相关讨论