如何在C/C++中无需拷贝合并两个指针指向的缓冲区？

这个问题的核心矛盾很清晰：第三方库的process函数要求一段连续的内存块（通过uchar*指针访问），但你手上是两个独立的、不连续的只读缓冲区，还想完全避免数据拷贝。咱们分情况讨论可行的实现方式：

1. 虚拟内存映射（真正无拷贝，平台相关） #

如果你的缓冲区是文件映射而来（比如通过mmap/CreateFileMapping读取文件），可以借助操作系统的虚拟内存机制，把两个独立的内存块映射到一段连续的虚拟地址空间里。这样process访问这段连续地址时，实际上会自动读写两个原始缓冲区的内容，完全不需要拷贝。

Linux 平台示例（文件映射缓冲区） #

#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstdint>
#include <cstdio>

// 模拟第三方库函数
void process(uint8_t* buffer, int size) {
    for (int i = 0; i < size; ++i) {
        printf("%d ", buffer[i]);
    }
    printf("\n");
}

int main() {
    // 假设top和bottom来自两个不同的文件（预先写入测试数据）
    int fd_top = open("top.bin", O_RDONLY);
    int fd_bottom = open("bottom.bin", O_RDONLY);
    if (fd_top == -1 || fd_bottom == -1) {
        perror("Failed to open files");
        return 1;
    }

    // 先分别映射两个文件到独立的虚拟地址
    uint8_t* top = static_cast<uint8_t*>(mmap(nullptr, 10, PROT_READ, MAP_PRIVATE, fd_top, 0));
    uint8_t* bottom = static_cast<uint8_t*>(mmap(nullptr, 10, PROT_READ, MAP_PRIVATE, fd_bottom, 0));
    if (top == MAP_FAILED || bottom == MAP_FAILED) {
        perror("Failed to map files");
        close(fd_top); close(fd_bottom);
        return 1;
    }

    // 创建一段20字节的连续虚拟内存区域
    uint8_t* combined = static_cast<uint8_t*>(mmap(
        nullptr, 20, PROT_READ, 
        MAP_ANONYMOUS | MAP_PRIVATE, -1, 0
    ));
    if (combined == MAP_FAILED) {
        perror("Failed to create combined mapping");
        munmap(top, 10); munmap(bottom, 10);
        close(fd_top); close(fd_bottom);
        return 1;
    }

    // 将top文件映射到combined的前10字节
    if (mmap(combined, 10, PROT_READ, MAP_FIXED | MAP_PRIVATE, fd_top, 0) == MAP_FAILED) {
        perror("Failed to remap top");
        goto cleanup;
    }
    // 将bottom文件映射到combined的后10字节
    if (mmap(combined + 10, 10, PROT_READ, MAP_FIXED | MAP_PRIVATE, fd_bottom, 0) == MAP_FAILED) {
        perror("Failed to remap bottom");
        goto cleanup;
    }

    // 现在可以直接把combined传给process，无拷贝！
    process(combined, 20);

cleanup:
    // 释放所有映射和文件句柄
    munmap(top, 10);
    munmap(bottom, 10);
    munmap(combined, 20);
    close(fd_top);
    close(fd_bottom);
    return 0;
}

Windows 平台思路 #

Windows下可以用VirtualAlloc创建连续的虚拟内存区域，再通过MapViewOfFile将两个文件映射到该区域的不同偏移位置，实现和Linux类似的无拷贝效果。

2. 栈/堆分配的缓冲区：几乎没有无拷贝方案 #

如果你的top和bottom是栈上的局部数组（比如你示例里的uchar top[10]）或者堆分配的内存（malloc/new），抱歉——操作系统不允许将这些内存重新映射到其他地址，没有安全的无拷贝方法能把它们合并成连续的虚拟内存块。

这种情况下最实用的方案就是老老实实拷贝数据到一个连续缓冲区：

#include <cstring>
#include <cstdint>

void process(uint8_t* buffer, int size);

int main() {
    uint8_t top[10] = {0,1,2,3,4,5,6,7,8,9};
    uint8_t bottom[10] = {10,11,12,13,14,15,16,17,18,19};
    
    uint8_t combined[20];
    memcpy(combined, top, 10);
    memcpy(combined + 10, bottom, 10);
    
    process(combined, 20);
    return 0;
}

如果拷贝的开销实在无法接受，你可以看看第三方库有没有支持分段处理的接口（比如传入多个缓冲区指针和大小），但这得看库的设计。

为什么直接传结构体不行？ #

你之前想的struct Buffer只是存储了两个指针，当你把&buffer传给uchar*参数时，process会把结构体的地址当成连续内存的起始地址——它访问的是结构体内部的指针值，而不是top/bottom缓冲区里的实际数据，这会直接导致未定义行为（比如崩溃、乱读数据），完全达不到预期效果。

内容的提问来源于stack exchange，提问作者vsw