C++如何在Linux实现高效文件操作 - 问答

在Linux环境下，使用C++进行高效的文件操作可以通过多种方式实现。以下是一些关键点和示例代码，帮助你提高文件操作的效率：

使用缓冲区：对于大量数据的读写，直接使用文件流（如std::ifstream和std::ofstream）可能不是最高效的方式。可以考虑使用缓冲区来减少系统调用的次数。

#include <iostream>
#include <fstream>
#include <vector>

const size_t BUFFER_SIZE = 1024 * 1024; // 1MB buffer

void copyFile(const std::string& src, const std::string& dest) {
    std::ifstream srcFile(src, std::ios::binary);
    std::ofstream destFile(dest, std::ios::binary);

    if (!srcFile.is_open() || !destFile.is_open()) {
        std::cerr << "Error opening files." << std::endl;
        return;
    }

    std::vector<char> buffer(BUFFER_SIZE);
    while (srcFile.read(buffer.data(), BUFFER_SIZE)) {
        destFile.write(buffer.data(), srcFile.gcount());
    }
    destFile.write(buffer.data(), srcFile.gcount()); // Copy the remaining data

    srcFile.close();
    destFile.close();
}

内存映射文件：内存映射文件是一种将文件或文件的一部分映射到进程的地址空间的技术。这可以显著提高大文件的读写性能。

#include <iostream>
#include <fstream>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

void memoryMappedFileCopy(const std::string& src, const std::string& dest) {
    int srcFd = open(src.c_str(), O_RDONLY);
    if (srcFd == -1) {
        std::cerr << "Error opening source file." << std::endl;
        return;
    }

    struct stat sb;
    if (fstat(srcFd, &sb) == -1) {
        std::cerr << "Error getting file size." << std::endl;
        close(srcFd);
        return;
    }

    char* srcData = static_cast<char*>(mmap(nullptr, sb.st_size, PROT_READ, MAP_PRIVATE, srcFd, 0));
    if (srcData == MAP_FAILED) {
        std::cerr << "Error mapping source file." << std::endl;
        close(srcFd);
        return;
    }

    int destFd = open(dest.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
    if (destFd == -1) {
        std::cerr << "Error opening destination file." << std::endl;
        munmap(srcData, sb.st_size);
        close(srcFd);
        return;
    }

    if (ftruncate(destFd, sb.st_size) == -1) {
        std::cerr << "Error resizing destination file." << std::endl;
        munmap(srcData, sb.st_size);
        close(srcFd);
        close(destFd);
        return;
    }

    char* destData = static_cast<char*>(mmap(nullptr, sb.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, destFd, 0));
    if (destData == MAP_FAILED) {
        std::cerr << "Error mapping destination file." << std::endl;
        munmap(srcData, sb.st_size);
        close(srcFd);
        close(destFd);
        return;
    }

    memcpy(destData, srcData, sb.st_size);

    munmap(srcData, sb.st_size);
    munmap(destData, sb.st_size);
    close(srcFd);
    close(destFd);
}

异步I/O：使用异步I/O可以避免阻塞主线程，提高程序的响应性和吞吐量。

#include <iostream>
#include <fstream>
#include <libaio.h>

void asyncWriteFile(const std::string& filePath, const std::string& data) {
    int fd = open(filePath.c_str(), O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
    if (fd == -1) {
        std::cerr << "Error opening file for writing." << std::endl;
        return;
    }

    io_context_t ctx = 0;
    if (io_setup(1, &ctx) < 0) {
        std::cerr << "Error initializing io_context." << std::endl;
        close(fd);
        return;
    }

    struct iocb cb;
    struct iocb* cbs[1] = {&cb};

    io_prep_pwrite(&cb, fd, data.data(), data.size(), 0);
    cb.aio_lio_opcode = IO_CMD_PWRITE;

    if (io_submit(ctx, 1, cbs) != 1) {
        std::cerr << "Error submitting async write." << std::endl;
    }

    io_getevents(ctx, 1, 1, nullptr, nullptr);

    io_destroy(ctx);
    close(fd);
}

使用sendfile系统调用：对于文件到文件的复制操作，sendfile系统调用可以非常高效，因为它避免了数据在内核空间和用户空间之间的多次拷贝。

#include <iostream>
#include <sys/sendfile.h>
#include <fcntl.h>
#include <unistd.h>

void sendFile(const std::string& src, const std::string& dest) {
    int srcFd = open(src.c_str(), O_RDONLY);
    if (srcFd == -1) {
        std::cerr << "Error opening source file." << std::endl;
        return;
    }

    int destFd = open(dest.c_str(), O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
    if (destFd == -1) {
        std::cerr << "Error opening destination file." << std::endl;
        close(srcFd);
        return;
    }

    off_t offset = 0;
    ssize_t bytesSent = sendfile(destFd, srcFd, &offset, 1); // Copy the entire file
    if (bytesSent == -1) {
        std::cerr << "Error sending file." << std::endl;
    }

    close(srcFd);
    close(destFd);
}

在使用这些技术时，请确保考虑到错误处理和资源管理，以避免潜在的问题。此外，根据具体的应用场景和需求，可能需要对这些示例进行适当的调整和优化。

0 赞

0 踩