C++中std::vector分块存储与合并的内存优化方案咨询

问题 #

将含100个Point对象的std::vector拆分为10个独立的std::vector分块，再将这些分块赋值给存于std::vector中的自定义Data结构体的trajectory属性。现有示例代码如下：

#include <vector>
#include <iostream>

class Point {
public:
    double x, y, z;

    Point(double x_val, double y_val, double z_val) : x(x_val), y(y_val), z(z_val) {}
};

class Data {
public:
    std::vector<Point> trajectory;

    // Constructor
    Data() = default;
};

int main() {
    std::vector<Point> original;

    // Same data - only example
    for (int i = 0; i < 100; ++i) {
        original.emplace_back(1.0, 2.0, 3.0); 
    }

    std::vector<Data> all_data;
    size_t chunk_size = 10;

    for (size_t i = 0; i < original.size(); i += chunk_size) {
        Data data;
        auto start = original.begin() + i;
        auto end = (i + chunk_size <= original.size()) ? start + chunk_size : original.end();

        data.trajectory.insert(data.trajectory.end(), start, end);

        all_data.emplace_back(data);
    }
}

希望在内存复杂度上优化，避免不必要的拷贝；同时想了解C中拷贝/移动对象的时机（使用GCC，可利用C20特性）；另外需要实现反向操作：将Data结构体属性中的分块重新合并为完整的std::vector。

解答 #

一、内存优化：避免不必要拷贝 #

针对你的代码，可通过以下方式减少拷贝开销：

1. 利用移动语义转移元素

使用std::move_iterator将原容器中的元素移动到分块容器，而非拷贝。对于Point这类轻量对象，移动和拷贝开销差异不大，但如果是包含堆内存的复杂对象，移动能大幅节省内存和时间。

同时，将Data对象移动到all_data中，避免拷贝整个Data结构体（包括其内部的vector）。

2. 预分配容器内存

提前用reserve()为分块vector分配足够空间，避免多次扩容导致的内存重新分配和元素拷贝。

优化后的拆分代码

#include <vector>
#include <algorithm> // 用于std::move

// ... Point和Data类定义不变 ...

int main() {
    std::vector<Point> original;
    for (int i = 0; i < 100; ++i) {
        original.emplace_back(1.0, 2.0, 3.0); 
    }

    std::vector<Data> all_data;
    const size_t chunk_size = 10;
    all_data.reserve(original.size() / chunk_size); // 预分配all_data的空间

    for (size_t i = 0; i < original.size(); i += chunk_size) {
        const size_t current_chunk_size = std::min(chunk_size, original.size() - i);
        
        // 直接在all_data中构造Data，减少一次Data对象的拷贝
        all_data.emplace_back();
        Data& current_data = all_data.back();
        current_data.trajectory.reserve(current_chunk_size); // 预分配分块空间

        // 移动原vector中的元素到分块
        std::move(original.begin() + i, 
                  original.begin() + i + current_chunk_size,
                  std::back_inserter(current_data.trajectory));
    }
}

关于C++拷贝/移动的时机

• 拷贝：当你通过值传递对象、将对象赋值给非引用变量、或显式调用拷贝构造/赋值函数时，会触发拷贝。比如原代码中all_data.emplace_back(data)，这里会拷贝data对象。
• 移动：当使用std::move()将对象转为右值、返回临时对象（编译器会触发NRVO优化，本质也是移动语义）、或调用移动构造/赋值函数时，会触发移动。移动会转移对象的内部资源（比如vector的堆内存指针），而非复制资源，开销极低。

二、反向合并分块 #

合并时同样可以利用预分配内存和移动语义优化：

合并代码

std::vector<Point> merge_data(std::vector<Data>& all_data) {
    std::vector<Point> merged;
    size_t total_size = 0;
    // 先计算总元素数，预分配内存
    for (const auto& data : all_data) {
        total_size += data.trajectory.size();
    }
    merged.reserve(total_size);

    // 合并元素：如果不需要保留原分块，用std::move更高效；否则用std::copy
    for (auto& data : all_data) {
        std::move(data.trajectory.begin(), data.trajectory.end(), std::back_inserter(merged));
        // 若需保留原分块，替换为：
        // std::copy(data.trajectory.begin(), data.trajectory.end(), std::back_inserter(merged));
    }
    return merged;
}

如果使用C++20，还可以用std::ranges::for_each简化遍历，但核心逻辑不变。

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