如何在Linux上用C++进行高效文件操作

在 Linux 环境下用 C++ 做文件操作，很多人第一反应是“用标准库就够了”。确实，大部分场景下 std::fstream 能搞定。但如果你追求极致性能，或者要处理大文件、并发读写，那标准库那套抽象层就不太够用了。下面从实操角度，拆解几个关键层级：从标准库的“傻瓜式”操作，到系统调用，再到内存映射，最后聊聊并发和错误处理——这些才是真正让文件操作变高效的“内功”。

1. 包含必要的头文件

先别急着写代码，把头文件理清楚。标准库的 iostream、fstream、string、vector 是基础层；如果要用系统调用，就得加上 sys/stat.h、fcntl.h、unistd.h；要是想玩内存映射，sys/mman.h 也少不了。一个典型的集合长这样：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

2. 使用标准库进行基本文件操作

日常读写小文件，标准库的 std::ifstream 和 std::ofstream 简洁又安全。下面这段代码基本是“教科书式”的写法：打开文件、写入、读取，顺便检查一下是否打开成功。注意，读取时用了 istreambuf_iterator，一次读入整个文件内容，比逐行读取快得多。

#include 

void writeFile(const std::string& filename, const std::string& content) {
    std::ofstream file(filename);
    if (file.is_open()) {
        file << content;
        file.close();
    } else {
        std::cerr << "Unable to open file for writing." << std::endl;
    }
}

std::string readFile(const std::string& filename) {
    std::ifstream file(filename);
    std::string content((std::istreambuf_iterator(file)), std::istreambuf_iterator());
    file.close();
    return content;
}

3. 使用低级系统调用进行高效文件操作

标准库虽然方便，但每次读写都经过一层缓存和抽象，吞吐量上不去。这时候就得请出 POSIX 系统调用：open、read、write、close。它们直接跟内核打交道，少了中间商赚差价。下面的代码封装了最朴素的四个操作，注意 open 的 flags 参数要按需传（比如 O_RDONLY、O_WRONLY、O_CREAT 等）。

#include 
#include 

int openFile(const std::string& filename, int flags) {
    return open(filename.c_str(), flags);
}

ssize_t readFile(int fd, void* buffer, size_t size) {
    return read(fd, buffer, size);
}

ssize_t writeFile(int fd, const void* buffer, size_t size) {
    return write(fd, buffer, size);
}

void closeFile(int fd) {
    close(fd);
}

4. 使用内存映射文件

如果文件动辄几百 MB 甚至 GB，用 read/write 来回拷贝数据会非常低效。内存映射（mmap）相当于把文件直接映射到进程的虚拟地址空间，读写文件就像读写内存一样。性能提升不是一星半点，尤其是随机访问场景。下面这段代码演示了只读映射：打开文件、获取大小、映射、使用完后解除映射。注意 mmap 返回的是 void*，可以直接转成 char* 来操作。

#include 
#include 
#include 
#include 

void* mapFile(const std::string& filename, size_t& size) {
    int fd = open(filename.c_str(), O_RDONLY);
    if (fd == -1) {
        return nullptr;
    }
    struct stat sb;
    if (fstat(fd, &sb) == -1) {
        close(fd);
        return nullptr;
    }
    size = sb.st_size;
    void* addr = mmap(nullptr, size, PROT_READ, MAP_PRIVATE, fd, 0);
    if (addr == MAP_FAILED) {
        close(fd);
        return nullptr;
    }
    close(fd);
    return addr;
}

void unmapFile(void* addr, size_t size) {
    munmap(addr, size);
}

5. 使用缓冲区

频繁调用系统调用（比如每次只读几个字节）是性能杀手。一个简单的优化：自己分配一个缓冲区，一次读一大块，然后从缓冲区里取数据。下面的代码用了一个 1MB 的 vector 作为缓冲区，每次调用 readFile 填满它，再处理。这样系统调用次数大幅减少，吞吐量自然上去了。

std::vector buffer(1024 * 1024); // 1MB buffer
ssize_t bytesRead = readFile(fd, buffer.data(), buffer.size());
if (bytesRead > 0) {
    // Process the data in buffer
}

6. 并发文件操作

多线程或多进程同时读写同一个文件，容易引发数据竞争。最简单的做法是加文件锁（比如 flock 或 fcntl 的 F_SETLK），或者用 POSIX 互斥锁保护共享的文件描述符。下面用 pthread_mutex_t 演示了最基础的线程安全模型：四个线程并发执行，但每次只有拿到锁的线程才能操作文件。

#include 

pthread_mutex_t fileMutex = PTHREAD_MUTEX_INITIALIZER;

void* threadFunc(void* arg) {
    pthread_mutex_lock(&fileMutex);
    // Perform file operations
    pthread_mutex_unlock(&fileMutex);
    return nullptr;
}

int main() {
    pthread_t threads[4];
    for (int i = 0; i < 4; ++i) {
        pthread_create(&threads[i], nullptr, threadFunc, nullptr);
    }
    for (int i = 0; i < 4; ++i) {
        pthread_join(threads[i], nullptr);
    }
    return 0;
}

7. 错误处理

系统调用失败时，返回值往往是 -1 或 NULL，同时 errno 会记录具体错误。千万别忽略这些检查——很多线上问题就出在“忘记检查返回值”。下面是最基本的错误处理模式：

int fd = open(filename.c_str(), O_RDONLY);
if (fd == -1) {
    perror("open");
    return -1;
}

从标准库到系统调用，再到内存映射和并发控制，每个层级都有它的适用场景。日常小文件用标准库足矣；追求吞吐量就用系统调用加缓冲区；大文件首选 mmap；多线程记得加锁。把这些要点串起来，Linux 上的 C++ 文件操作基本就稳了。