怎样用C++实现零拷贝数据传输 使用move语义与内存映射文件

std::span

span

read()

write()

read()

write()

std::vector<char>

std::vector

vector

mmap()

CreateFileMapping()

MapViewOfFile()

#include <iostream>
#include <fstream>
#include <string>
#include <sys/mman.h> // for mmap, munmap
#include <sys/stat.h> // for fstat
#include <fcntl.h>    // for open
#include <unistd.h>   // for close

// 这是一个简化的例子，没有完整的错误处理
// 在生产代码中，你需要对所有系统调用进行错误检查
int main() {
    const char* filename = "example.txt";
    const char* data = "Hello, zero-copy world!";
    size_t data_len = std::string(data).length();

    // 1. 创建并写入一个文件
    std::ofstream ofs(filename);
    if (!ofs.is_open()) {
        std::cerr << "Failed to create file." << std::endl;
        return 1;
    }
    ofs << data;
    ofs.close();

    // 2. 打开文件获取文件描述符
    int fd = open(filename, O_RDWR); // 读写模式
    if (fd == -1) {
        perror("open");
        return 1;
    }

    // 3. 获取文件大小
    struct stat st;
    if (fstat(fd, &st) == -1) {
        perror("fstat");
        close(fd);
        return 1;
    }
    size_t file_size = st.st_size;

    // 4. 内存映射文件
    void* mapped_addr = mmap(nullptr, file_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (mapped_addr == MAP_FAILED) {
        perror("mmap");
        close(fd);
        return 1;
    }

    // 5. 直接通过指针访问文件内容
    char* file_content = static_cast<char*>(mapped_addr);
    std::cout << "Original content: " << std::string(file_content, file_size) << std::endl;

    // 6. 修改映射区域，修改会同步回文件
    if (file_size >= 5) { // 确保有足够的空间修改
        file_content[0] = 'X';
        file_content[1] = 'Y';
        file_content[2] = 'Z';
        std::cout << "Modified content in memory: " << std::string(file_content, file_size) << std::endl;
    }

    // 7. 解除映射
    if (munmap(mapped_addr, file_size) == -1) {
        perror("munmap");
    }

    // 8. 关闭文件描述符
    close(fd);

    // 9. 重新打开文件验证修改
    std::ifstream ifs(filename);
    std::string new_content((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
    std::cout << "Content after re-opening file: " << new_content << std::endl;

    // 清理文件
    remove(filename);

    return 0;
}

read

write

std::move

&&

std::move

std::vector

std::string

BigDataContainer

class BigDataContainer {
public:
    int* data;
    size_t size;

    // 构造函数
    BigDataContainer(size_t s) : size(s) {
        data = new int[size];
        std::cout << "Constructor: Allocated " << size * sizeof(int) << " bytes." << std::endl;
    }

    // 析构函数
    ~BigDataContainer() {
        delete[] data;
        std::cout << "Destructor: Deallocated." << std::endl;
    }

    // 拷贝构造函数 (深拷贝)
    BigDataContainer(const BigDataContainer& other) : size(other.size) {
        data = new int[size];
        std::copy(other.data, other.data + size, data);
        std::cout << "Copy Constructor: Deep copy." << std::endl;
    }

    // 移动构造函数 (浅拷贝 + 源对象置空)
    BigDataContainer(BigDataContainer&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr; // 源对象不再拥有资源
        other.size = 0;
        std::cout << "Move Constructor: Resource moved." << std::endl;
    }

    // 拷贝赋值运算符
    BigDataContainer& operator=(const BigDataContainer& other) {
        if (this != &other) {
            delete[] data; // 释放旧资源
            size = other.size;
            data = new int[size];
            std::copy(other.data, other.data + size, data);
            std::cout << "Copy Assignment: Deep copy." << std::endl;
        }
        return *this;
    }

    // 移动赋值运算符
    BigDataContainer& operator=(BigDataContainer&& other) noexcept {
        if (this != &other) {
            delete[] data; // 释放旧资源
            data = other.data;
            size = other.size;
            other.data = nullptr; // 源对象不再拥有资源
            other.size = 0;
            std::cout << "Move Assignment: Resource moved." << std::endl;
        }
        return *this;
    }
};

BigDataContainer createBigContainer() {
    return BigDataContainer(1000000); // 返回一个临时对象
}

void processContainerByValue(BigDataContainer c) {
    std::cout << "Processing container by value." << std::endl;
    // ...
}

int main() {
    std::cout << "--- Creating c1 ---" << std::endl;
    BigDataContainer c1(500000); // 调用普通构造函数

    std::cout << "\n--- Creating c2 from c1 (copy) ---" << std::endl;
    BigDataContainer c2 = c1; // 调用拷贝构造函数，深拷贝

    std::cout << "\n--- Creating c3 from temporary (move) ---" << std::endl;
    BigDataContainer c3 = createBigContainer(); // 调用移动构造函数，避免深拷贝

    std::cout << "\n--- Passing c3 to function by value (move) ---" << std::endl;
    processContainerByValue(std::move(c3)); // 显式移动c3，避免深拷贝

    std::cout << "\n--- c3 after move (should be empty) ---" << std::endl;
    // 此时c3的data指针已为nullptr，不再拥有资源

    std::cout << "\n--- Assigning c1 to c4 (copy) ---" << std::endl;
    BigDataContainer c4(100);
    c4 = c1; // 调用拷贝赋值

    std::cout << "\n--- Assigning temporary to c5 (move) ---" << std::endl;
    BigDataContainer c5(100);
    c5 = createBigContainer(); // 调用移动赋值

    std::cout << "\n--- End of main ---" << std::endl;
    return 0;
}

createBigContainer()

processContainerByValue

int