Question

我有一个数组数组：struct chunk { char * data; size_t size; }; chunk * chunks;。每个块中的数据大小是动态的，并且块之间不同。通过嵌套的for循环，可以轻松地线性访问数据：

for (chunk * chunk_it = chunks; chunk_it != chunks + count; ++chunk_it) {
    for (char * it = chunk_it->data; it != chunk_it->data + chunk_it->size; ++it) {
        /* use it here */
    }
}

我想使用chunks->data作为界面，将多个块转化为对operator[]的随机访问。

通过线性搜索正确的块，然后仅计算所需数据的偏移量来工作。

template <class T>
void random_access(int n) {
    chunk * c;
    for (int i = 0; i < count; ++i) {
        c = chunks + i;
        size_t size = c->size;
        if (n - size < 0) {
            n -= size; // mutate n to fit into current chunk
        } else {
            break; // found
        }
    }

    T * data = reinterpret_cast<T *>(c->data + n);

    // use data here
}

有没有更有效的方法？每当我需要大块的T时这样做都是疯狂的。我打算线性地迭代所有块数据，但是我想在函数外部使用数据，因此需要在内部循环中返回它（因此为什么要将其内外翻转）。我还想到了在内部循环中使用函数指针，但不仅仅是做chunk_iterator[n]更好。

Answer 1

我了解您的数据结构更为复杂，但是您不能这样做吗？

我构建了一个块数据的连续块，并在 chunks数组中记录了每个块的 position 和 size 。 / em>：

class chunk_manager { struct chunk { std::size_t position; std::size_t size; chunk(std::size_t position, std::size_t size) : position(position), size(size) {} }; public: void add_chunk(std::string const& chunk) { m_chunks.emplace_back(m_data.size(), chunk.size()); m_data.append(chunk); } char* random_access(std::size_t n) { return &m_data[n]; } std::size_t size_in_bytes() const { return m_data.size(); } private: std::vector<chunk> m_chunks; std::string m_data; }; int main() { chunk_manager cm; cm.add_chunk("abc"); cm.add_chunk("def"); cm.add_chunk("ghi"); for(auto n = 0ULL; n < cm.size_in_bytes(); ++n) std::cout << cm.random_access(n) << '\n'; }

随机访问不同大小的原始缓冲区数组？

1 个答案: