C++ C++；通过多次重复向量来构建数据数组

我有一个数字序列，我需要重复多次，并将重复的数据作为沿着大小（实际上是元素计数）指向数据的指针。我需要这些数据将其传递给API

分配内存、传递重复数据然后再次释放数据的最有效方法是什么。我目前有一个需要重复的序列存储在std:：vector中

我的一些想法是：

// Setup code
unsigned int repeat = 30000;
std::vector<int> datavector(5, 0); // assume this would contain arbitrary numbers that needed to be repeated

// Idea 1:
{
    unsigned int byte_size_step = datavector.size() * sizeof(int);
    unsigned int byte_full_size = byte_size_step * repeat;
    int *ptr = malloc(byte_full_size);

    for(unsigned int i=0; i<repeat; i++)
    {
        memcpy(ptr+(i*byte_size_step), datavector.data(),  byte_size_step);
    }
    apiFunc(ptr); // apiFunc copies the data
    free(ptr)
}

// Idea 2:
{
    std::vector datarepeated(datavector.size()*repeat);
    for(unsigned int i=0; i<repeat; i++)
    {
        datarepeated.insert(datarepeated.begin()+(i*size_step), datavector.begin(), datavector.end());
    }
    apiFunc(datarepeated.data());
}

//设置代码
无符号整数重复=30000；
向量数据向量（5，0）；//假设这将包含需要重复的任意数字
//想法1：
{
无符号整数字节\大小\步长=datavector.size（）*sizeof（int）；
无符号整数字节\完整\大小=字节\大小\步骤*重复；
int*ptr=malloc（字节大小）；
对于（unsigned int i=0；i您的两个想法应该具有非常相似的性能。但是，您可以通过最小化循环迭代次数/
memcpy
调用来获得更高的性能，这可以通过在每次迭代时将长度加倍来实现。类似这样：

// Setup code
const size_t repeat = 10;
int data[] = {1, 2, 3, 4, 5};
vector<int> datavec(data, data+5);

// initialize and copy initial segment
vector<int> datarepeated(datavec.size() * repeat);
memcpy(&datarepeated[0], &datavec[0], datavec.size()*sizeof(int));
size_t num_copied = datavec.size();
size_t num_total = datarepeated.size();

// double the amount copied at each iteration
while(num_copied*2 <= num_total) {
    memcpy(&datarepeated[num_copied], &datarepeated[0], num_copied*sizeof(int));
    num_copied *= 2;
}

// copy the final bit
if(num_copied < num_total)
    memcpy(&datarepeated[num_copied], &datarepeated[0], (num_total-num_copied)*sizeof(int));

//设置代码
const size\u t repeat=10；
int data[]={1,2,3,4,5}；
矢量数据矢量（数据，数据+5）；
//初始化并复制初始段
向量datarepeated（datavec.size（）*repeat）；
memcpy（&datarepeated[0]，&datavec[0]，datavec.size（）*sizeof（int））；
size_t num_copied=datavec.size（）；
size_t num_total=datarepeated.size（）；
//每次迭代复制的数量加倍
while（num_copied*2您的性能瓶颈在哪里？您是否分析了您的应用程序？是否存在内存分配、数据复制等方面的问题？如果不回答这些问题，就不可能定义“最高效”。在您测量整个系统并找到瓶颈之前，我会说：代码越少越好。不要尝试过早优化。您是否尝试过
复制（datavector.begin（）、datavector.end（）、back_inserter（datarepeated））
在循环内部查看它的性能如何？标准库可能为整数类型优化了范围副本，这些整数类型要么接近，要么等于
memcpy（）
，尽管在速度方面很难击败它。另一种选择是使用
reserve（）
对于初始目标缓冲区扩展，而不是构造大小，然后进行适当的末端插入。这避免了初始向量的所有值初始化。使用静态分配的缓冲区而不是malloced缓冲区如何？动态内存分配比较昂贵（相对而言）。如果这真的很重要，那么如何更改apiFunc（），使其不需要重复数据？但我觉得这只是一个过早的优化。先测量，然后再优化。@dmitri动态内存分配实际上并没有那么慢，不管大家怎么说。只有在严格循环的情况下才成为问题（但在一个紧密循环中所做的一切都是一个潜在问题）。但在这种情况下，只有一个动态alloc，与数据复制相比，该开销将是微不足道的。此外，静态分配有时是不可能的，例如，如果您在编译时不知道大小，或者如果您需要太多，可能会溢出堆栈（在这种情况下可能会发生，具体取决于编译器）。这就是我所说的：在获得测量值之前，谈论效率是没有意义的。在此之前，任何事情都不慢。静态alloc：您也可以分配一次缓冲区，如果缓冲区的大小很小，则将其大小加倍，等等。这将减少alloc的数量。等等。。。