C++ 要读取文件，哪一个会更快？使用fstream、file*还是内存映射？

这是我的项目配置：vs2013，win32，调试

我想知道不同的文件大小，这3种文件读取方法中哪一种会更快，它们是C++风格的FSt流、C风格的文件读写和内存映射。p> 但在执行之后，我的结果如下：

文件大小1225284
fstream时间47
c文件指针时间0
内存映射时间0

文件大小14856192
fstream时间15
c文件指针时间0
内存映射时间47

文件大小97198080
fstream时间16
c文件指针时间0
内存映射时间265

文件大小1259530844
fstream时间31
c文件指针时间16
内存映射时间11138

对于流和文件*读取，读取文件所需的时间似乎不会随着文件大小的增加而增加。但对于内存映射，这是事实。这种现象非常奇怪。
因为在我看来，对于大文件，内存映射会更快。 这是我的密码：

string ifile = "M:/Thesis/FileReadCmp/1.txt";
string os = "M:/Thesis/FileReadCmp/new_cmp1.txt";
int page_size = 2 * 1024 * 64 * 1024;//128M
for (int j = 0; j < 100; ++j){
    os[os.size() - 5] = '1' + j;
    ofstream o(os);
    for (int i = 0; i < 4; ++i){
        ifile[ifile.size() - 5] = '1' + i;
        ifstream in(ifile);

        in.seekg(0, ios::end);
        o << "File Size " << in.tellg() << endl;
        o << endl;
        in.close();

        //using fstream to read file
        long long st = GetTickCount();
        in.open(ifile);
        char c;
        while (in >> c){
            ;
        }
        in.close();             
        long long et = GetTickCount();
        o << "fstream time " << et - st << endl;

        //using FILE* to read file
        st = GetTickCount();
        FILE* cpf = fopen(ifile.c_str(), "r");
        char cc = fgetc(cpf);
        while (cc != EOF)
        {
            cc = fgetc(cpf);
        }
        fclose(cpf);
        et = GetTickCount();
        o << "c file pointer time " << et - st << endl;

        //using memory mapping to read file
        const char* pc = ifile.c_str();
        st = GetTickCount();
        HANDLE hFile = CreateFile(pc, GENERIC_WRITE | GENERIC_READ, 0,
            NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
        int file_size = GetFileSize(hFile, NULL);
        HANDLE hFileMap = OpenFileMapping(FILE_MAP_READ | FILE_MAP_WRITE, FALSE,
            TEXT("SharedData"));

        if (hFileMap == NULL){
            // if no such object,create a file mapping object
            hFileMap = CreateFileMapping(hFile, NULL, PAGE_READWRITE,
                0, 0, TEXT("SharedData"));
        }

            int rem_file_size = file_size;
            int offset = 0;
            while (rem_file_size > page_size){
                PVOID pvFileView = MapViewOfFile(hFileMap, FILE_MAP_WRITE, 0, offset, page_size);
                char* asc_dex = (char*)pvFileView;
                for (int i = 0; i < page_size; ++i){//, c = 0++c
                    char c = asc_dex[i];
                }
                //UnmapViewOfFile(pvFileView);
                offset += page_size;
                rem_file_size -= page_size;
            }
            PVOID pvFileView = MapViewOfFile(hFileMap, FILE_MAP_WRITE, 0, offset, rem_file_size);
            char* asc_dex = (char*)pvFileView;
            for (int i = 0; i < rem_file_size; ++i){//, c = 0++c
                char c = asc_dex[i];
            }
            UnmapViewOfFile(pvFileView);

        CloseHandle(hFileMap);
        CloseHandle(hFile);

        et = GetTickCount();
        o << "memory mapping time " << et - st << endl;
        o << endl;
    }
}

string ifile=“M:/Thesis/FileReadCmp/1.txt”；
string os=“M:/Thesis/FileReadCmp/new_cmp1.txt”；
int page_size=2*1024*64*1024//128米
对于（int j=0；j<100；++j）{
os[os.size（）-5]=“1”+j；
o（os）流；
对于（int i=0；i<4；++i）{
ifile[ifile.size（）-5]=“1”+i；
ifstream-in（ifile）；
in.seekg（0，ios：：end）；
o最有效的方法是保持输入流的流动。通常，这意味着读取大数据块（每个请求读取更多数据）

一种方法是使用多个缓冲区（在internet上搜索“双缓冲”）和多个线程

读取线程将读取并填充一个缓冲区，然后发出数据准备就绪的信号。读取线程将继续填充下一个缓冲区

处理线程（正在等待读取信号）唤醒并开始处理缓冲区，然后输出数据

一个目标是使用尽可能多的大的缓冲区来调整读取数据的速度与处理速度。同样，这个想法是数据的读取相对于处理是连续的。
问题可能是开放模式。内存映射的默认开放模式是二进制的

当我将.open（ifile）

改为.open（ifile，ios:：binary）

文件*cpf=fopen（ifile.c_str（），“r”）

为

文件*cpf=fopen（ifile.c_str（），“rb”）

时，3种方法的实际运行时间与理论一致。它们如下：

文件大小1225284
fstream时间297
c文件指针时间93
内存映射时间0

文件大小14856192
fstream时间3167
c文件指针时间1045
内存映射时间47

文件大小97198080
fstream时间20779
c文件指针时间6833
内存映射时间281

文件大小1259530844
fstream时间268696
c文件指针时间88406
内存映射时间11216

---

为什么要分别映射每个页面？因为对于1GB大小的文件，我无法映射整个文件。最让我困惑的是使用stream和file的读取速度*@immibisI已经删除了unmpviewoffile（pvFileView）；在循环中。@immibisWhoops，我没有注意到您有128MB页面-我假设页面大小是页面大小（仅4kB）。具有128MB“页面”，映射每个文件的开销应该不是问题。我认为

UnmapViewOfFile

应该在循环中；否则这是一个漏洞，不是吗？你的建议很好。但是对于3种文件读/写方法？对于不同类型的文件，如果我不使用上面提到的方法，哪一种会更好？@Thomas MatthewsWhen读取数据fr对于文件，文件类型无关紧要。您希望输入数据，然后进行分析（解析）数据。打开和读取数据可能比使用内存映射更快。内存映射取决于操作系统，操作系统可能需要执行上下文切换或分页以适应请求。当您自己读取文件时，您可以管理何时读取以及分配的内存量。