我正在编写一个内部循环，该循环需要将struct放置在连续存储中。我不知道这些struct会提前多少。我的问题是STL的vector将其值初始化为0，所以无论我做什么，我都会承担初始化的费用以及将struct成员设置为其值的费用。

是否有任何方法可以防止初始化，或者那里有一个带有STL的容器，该容器具有可调整大小的连续存储和未初始化的元素？

(我确定需要对代码的这一部分进行优化，并且我确定初始化会花费大量的成本。)

另外，请参阅以下我的评论，以了解有关何时进行初始化的说明。

某些代码：

void GetsCalledALot(int* data1, int* data2, int count) {
    int mvSize = memberVector.size()
    memberVector.resize(mvSize + count); // causes 0-initialization

    for (int i = 0; i < count; ++i) {
        memberVector[mvSize + i].d1 = data1[i];
        memberVector[mvSize + i].d2 = data2[i];
    }
}

解决方案

使用std :: vector :: reserve()方法。它不会调整向量的大小，但是会分配空间。

呃...

尝试方法：

std::vector<T>::reserve(x)

这将使我们能够为x项保留足够的内存，而无需初始化任何项(向量仍然为空)。因此，只有经过x才可以进行重新分配。

第二点是向量不会将值初始化为零。我们是否正在调试中测试代码？

在g ++上验证后，以下代码：

#include <iostream>
#include <vector>

struct MyStruct
{
   int m_iValue00 ;
   int m_iValue01 ;
} ;

int main()
{
   MyStruct aaa, bbb, ccc ;

   std::vector<MyStruct> aMyStruct ;

   aMyStruct.push_back(aaa) ;
   aMyStruct.push_back(bbb) ;
   aMyStruct.push_back(ccc) ;

   aMyStruct.resize(6) ; // [EDIT] double the size

   for(std::vector<MyStruct>::size_type i = 0, iMax = aMyStruct.size(); i < iMax; ++i)
   {
      std::cout << "[" << i << "] : " << aMyStruct[i].m_iValue00 << ", " << aMyStruct[0].m_iValue01 << "\n" ;
   }

   return 0 ;
}

给出以下结果：

[0] : 134515780, -16121856
[1] : 134554052, -16121856
[2] : 134544501, -16121856
[3] : 0, -16121856
[4] : 0, -16121856
[5] : 0, -16121856

我们看到的初始化可能是工件。

[编辑]关于调整大小的评论之后，我修改了代码以添加调整大小行。调整大小有效地调用了vector内部对象的默认构造函数，但是如果默认构造函数不执行任何操作，则不会初始化任何内容……我仍然相信这是一个伪像(我设法第一次将整个向量与以下代码：

aMyStruct.push_back(MyStruct()) ;
aMyStruct.push_back(MyStruct()) ;
aMyStruct.push_back(MyStruct()) ;

所以...
：-/

[编辑2]就像Arkadiy已经提供的那样，解决方案是使用带有所需参数的内联构造函数。就像是

struct MyStruct
{
   MyStruct(int p_d1, int p_d2) : d1(p_d1), d2(p_d2) {}
   int d1, d2 ;
} ;

这可能会内联到代码中。

但是无论如何，我们都应该使用探查器来研究代码，以确保这段代码是应用程序的瓶颈。

结构本身是否需要在连续内存中，还是可以避免使用struct *向量？

向量会复制我们添加的内容，因此使用指针向量而不是对象是提高性能的一种方法。

我不认为STL是答案。我们将需要使用realloc()推出自己的解决方案。我们必须存储一个指针以及元素的大小或者数量，并使用该指针查找在realloc()之后开始添加元素的位置。

int *memberArray;
int arrayCount;
void GetsCalledALot(int* data1, int* data2, int count) {
    memberArray = realloc(memberArray, sizeof(int) * (arrayCount + count);
    for (int i = 0; i < count; ++i) {
        memberArray[arrayCount + i].d1 = data1[i];
        memberArray[arrayCount + i].d2 = data2[i];
    }
    arrayCount += count;
}

因此，这里的问题是，调整大小是调用insert，它是对每个新添加的元素从默认构造的元素进行复制构造。为了使此成本为0，我们需要将自己的默认构造函数和自己的副本构造函数编写为空函数。对副本构造函数执行此操作是一个非常糟糕的主意，因为它将破坏std :: vector的内部重新分配算法。

简介：我们将无法使用std :: vector做到这一点。

要澄清reserve()响应：我们需要将reserve()与push_back()结合使用。这样，不是为每个元素调用默认构造函数，而是为副本构造函数调用。我们仍然要承担在堆栈上设置结构，然后将其复制到向量的代价。另一方面，如果我们使用

vect.push_back(MyStruct(fieldValue1, fieldValue2))

编译器将直接在属于该向量的内存中构造新实例。这取决于优化器的智能程度。我们需要检查生成的代码以找出答案。

从评论到其他海报，我们似乎都剩下malloc()和朋友了。向量不会让我们拥有未构造的元素。

从代码看来，我们似乎有一个结构向量，每个结构都包含2个整数。我们可以改用2个int向量吗？然后

copy(data1, data1 + count, back_inserter(v1));
copy(data2, data2 + count, back_inserter(v2));

现在，我们不必每次都为复制一个结构付费。

我会做类似的事情：

void GetsCalledALot(int* data1, int* data2, int count)
{
  const size_t mvSize = memberVector.size();
  memberVector.reserve(mvSize + count);

  for (int i = 0; i < count; ++i) {
    memberVector.push_back(MyType(data1[i], data2[i]));
  }
}

我们需要为memberVector中存储的类型定义一个ctor，但这是一个很小的开销，因为它将为我们提供两全其美的优势。不会进行不必要的初始化，并且在循环期间不会发生任何重新分配。

std :: vector必须以某种方式初始化数组中的值，这意味着必须调用某些构造函数(或者复制构造函数)。如果要像访问初始化数组一样访问数组的未初始化部分，则" vector"(或者任何容器类)的行为是不确定的。

最好的方法是使用reserve()和push_back()，以便使用copy-constructor，避免默认构造。

使用示例代码：

struct YourData {
    int d1;
    int d2;
    YourData(int v1, int v2) : d1(v1), d2(v2) {}
};

std::vector<YourData> memberVector;

void GetsCalledALot(int* data1, int* data2, int count) {
    int mvSize = memberVector.size();

    // Does not initialize the extra elements
    memberVector.reserve(mvSize + count);

    // Note: consider using std::generate_n or std::copy instead of this loop.
    for (int i = 0; i < count; ++i) {
        // Copy construct using a temporary.
        memberVector.push_back(YourData(data1[i], data2[i]));
    }
}

像这样调用reserve()(或者resize())的唯一问题是，我们最终可能会调用复制构造函数的次数超出了需要。如果我们可以对数组的最终大小做出正确的预测，则最好在开始时reserve()一次。但是，如果我们不知道最终尺寸，则至少平均份数会最少。

在当前版本的C ++中，内部循环的效率不高，因为在堆栈上构造了一个临时值，然后将其复制构造到向量存储器中，最后该临时项被销毁了。但是，下一版本的C ++具有称为R-Value引用(T &&)的功能，该功能将有所帮助。

std :: vector提供的接口不允许其他选择，即使用一些类似于工厂的类来构造默认值以外的值。这是在C ++中实现该模式的大致示例：

template <typename T>
class my_vector_replacement {

    // ...

    template <typename F>
    my_vector::push_back_using_factory(F factory) {
        // ... check size of array, and resize if needed.

        // Copy construct using placement new,
        new(arrayData+end) T(factory())
        end += sizeof(T);
    }

    char* arrayData;
    size_t end; // Of initialized data in arrayData
};

// One of many possible implementations
struct MyFactory {
    MyFactory(int* p1, int* p2) : d1(p1), d2(p2) {}
    YourData operator()() const {
        return YourData(*d1,*d2);
    }
    int* d1;
    int* d2;
};

void GetsCalledALot(int* data1, int* data2, int count) {
    // ... Still will need the same call to a reserve() type function.

    // Note: consider using std::generate_n or std::copy instead of this loop.
    for (int i = 0; i < count; ++i) {
        // Copy construct using a factory
        memberVector.push_back_using_factory(MyFactory(data1+i, data2+i));
    }
}

这样做确实意味着我们必须创建自己的向量类。在这种情况下，它也应该使一个简单的例子变得复杂。但是有时候有时候使用这样的工厂函数会更好，例如，如果insert以其他值作为条件，并且我们将不得不无条件地构造一些昂贵的临时对象，即使实际上并不需要它。

C ++ 0x在vector中添加了一个新的成员函数模板emplace_back(依赖于可变参数模板和完美的转发)，它完全摆脱了任何临时对象：

memberVector.emplace_back(data1[i], data2[i]);