C++ 如何高效地在数组中插入多个值（使用C+；+；17或更早版本）？

给定一个数组，其中m个条目的大小为3:

n=m*3

。在

m

值之后的每个位置上，应插入一个新值，该值的大小在

n=m*4

之后

我的天真方法是创建一个具有新大小的较大数组，然后在数组上迭代，将值复制到新数组中，每m步添加一个新数组迭代步骤并填充新值。 下面的示例代码可能有助于理解我试图实现的目标

我想这可能没有效率。不幸的是，这种数组交错经常执行。因此，代码应该是高效的，以避免计算时间过长

当前的标准库中还有哪些其他策略和工具可供使用？该示例使用一个数组，但我对其他容器开放

编辑：示例代码

#include <omp.h>
#include <cstdlib>

int main(int argc, char* argv[])
{

    const auto arrSize = 52428800; // entries for the initial array
    auto arr = new double[arrSize * 3]; // 3 sequential elements are a group

    #pragma omp parallel for
    for( auto i = 0; i < arrSize*3; ++i)
    {
        arr[i] = 1.0*i/arrSize;
    }

    auto larr = new double[arrSize * 4]; // larger array with space for interleaving elements

    #pragma omp parallel
    #pragma omp for
    for (auto i = 0; i < arrSize; ++i) // after each element group of three a new element should be inserted
    {
        auto k = 0;
        auto j = i*3;
        for(k=0; k < 3; ++k)
        {
            larr[i*4+k] = arr[j+k];
        }
        larr[i*4+k] = 0;
    }

    delete[] arr;
    delete[] larr;

    return EXIT_SUCCESS;
}

#包括
#包括
int main（int argc，char*argv[]）
{
const auto arrSize=52428800；//初始数组的条目
auto-arr=new double[arrSize*3]；//3个连续元素是一个组
#pragma-omp并行
用于（自动i=0；i

您的元素是否需要在内存中按顺序排列？如果没有，您可以有一个向量向量，并在访问向量时进行交错

就我个人而言，我会使用一个自定义容器类来包装一个

向量

：

---

这不是一个完整的容器类，只是一个一般概念。它缺少迭代器等。。。。如何完成它，并使它更好地适合您的用例，留给读者作为练习

如果您知道它将很频繁，那么可能数组不是开始使用的正确容器？也许一个链表会是一个更好的选择？你是一步插入新元素吗？那么每一个“*3”同时增长到“*4”？或者以m步为单位，但有序（第一个元素先增长，第m个元素最后增长）？如何访问现有元素？是否要一次访问单个元素？还是一个“跨步”（“*3”，“*4”）？任意数量的元素？多久一次？数组是一次增长还是逐步增长并不重要。调整大小期间，阵列元素不会更改。只能出于调整大小的目的访问它们。一次处理多少个元素是任意的。运行调整大小的次数可能有数千（我没有一个数字）。调整大小后，元素以4的步幅处理。这个问题的措辞不是特别清楚。它一开始看起来像是有

std:：array

（一个包含

m

条目的数组，每个条目大小为3），但是“m之后的每个位置”是什么？插入新的（3字节）值会导致每个值增加到4字节？这是什么下标？也许你可以用一些声明来补充你的问题，以说明我们正在处理什么？了解为什么选择一个数组而不是另一个容器也可能很有用。@JaMiT我添加了一段代码来澄清我的问题。

a

下标只是一个运行索引，使描述更为一般。

template <class T>
class interleaved_vector 
{
    std::vector< std::vector <T> > data;

  public:
    void interleave(const std::vector <T> & v)
    {
       data.push_back(v);
    }

    /* I am a little bit rusty on move-semantics, so I don't guarantee this is 
       correct */
    void interleave(std::vector &&v)
    {
       data.push_back(std::move(v));
    }

    // Access the data in an interleaved way
    // This assumes all the interleaved vectors have the same size.
    T operator[] (size_t i) const
    {
       size_t i1 = i / data.front().size();
       size_t i2 = i % data.front().size();

       return data[i1][i2];
    }

    T & operator[] (size_t i)
    {
       size_t i1 = i / data.front().size();
       size_t i2 = i % data.front().size();

       return data[i1][i2];
    }

 }

interleaved_vector<int> iv;

// populate the vector 

std::vector<int> v(m)

iv.interleave(v);
iv.interleave(v);
iv.interleave(v);

// populate it using move-semantic
iv.interleave(std::move(v));

// read the n-th element after interleaving
int i = iv[n];

// set the n-th element after interleaving 
iv[n] = 1234;