I'm writing an inner loop that needs to place structs in contiguous storage. I don't know how many of these structs there will be ahead of time. My problem is that STL's vector initializes its values to 0, so no matter what I do, I incur the cost of the initialization plus the cost of setting the struct's members to their values.

Is there any way to prevent the initialization, or is there an STL-like container out there with resizeable contiguous storage and uninitialized elements?

(I'm certain that this part of the code needs to be optimized, and I'm certain that the initialization is a significant cost.)

Also, see my comments below for a clarification about when the initialization occurs.


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

        memberVector[mvSize + i].d1 = data1[i];
        memberVector[mvSize + i].d2 = data2[i];
  • 1
    Note - using reserve() is not a solution, since you can't legally access the data that's at locations end() and above. – Jim Hunziker Sep 18 '08 at 20:36
  • 1
    Another clarification: it's not that the constructor initializes the values to 0. It's that resize calls insert, which does. – Jim Hunziker Sep 18 '08 at 20:42
  • Could you give us the struct declaration, too? Thanks... :-) – paercebal Sep 18 '08 at 21:00
  • 1
    NOTE: you can't access data that's uninitialized anyway. Same issue for vector<T> past .end() and uninitialized members of a T[]. But with a vector, chances are the debugging code tells you that now. The array code will fail silently on the customers PC. – MSalters Sep 19 '08 at 11:24
  • This is a good question. For some applications, it is important to realize that std::vector always initializes its elements, even if they are plain-old-data (POD). – nobar Nov 11 '09 at 3:52

14 Answers 14


std::vector must initialize the values in the array somehow, which means some constructor (or copy-constructor) must be called. The behavior of vector (or any container class) is undefined if you were to access the uninitialized section of the array as if it were initialized.

The best way is to use reserve() and push_back(), so that the copy-constructor is used, avoiding default-construction.

Using your example code:

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

std::vector<YourData> memberVector;

    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.
        // Copy construct using a temporary.
        memberVector.push_back(YourData(data1[i], data2[i]));

The only problem with calling reserve() (or resize()) like this is that you may end up invoking the copy-constructor more often than you need to. If you can make a good prediction as to the final size of the array, it's better to reserve() the space once at the beginning. If you don't know the final size though, at least the number of copies will be minimal on average.

In the current version of C++, the inner loop is a bit inefficient as a temporary value is constructed on the stack, copy-constructed to the vectors memory, and finally the temporary is destroyed. However the next version of C++ has a feature called R-Value references (T&&) which will help.

The interface supplied by std::vector does not allow for another option, which is to use some factory-like class to construct values other than the default. Here is a rough example of what this pattern would look like implemented in 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;

    // ... Still will need the same call to a reserve() type function.

        // Copy construct using a factory
        memberVector.push_back_using_factory(MyFactory(data1+i, data2+i));

Doing this does mean you have to create your own vector class. In this case it also complicates what should have been a simple example. But there may be times where using a factory function like this is better, for instance if the insert is conditional on some other value, and you would have to otherwise unconditionally construct some expensive temporary even if it wasn't actually needed.


C++0x adds a new member function template emplace_back to vector (which relies on variadic templates and perfect forwarding) that gets rid of any temporaries entirely:

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

To clarify on reserve() responses: you need to use reserve() in conjunction with push_back(). This way, the default constructor is not called for each element, but rather the copy constructor. You still incur the penalty of setting up your struct on stack, and then copying it to the vector. On the other hand, it's possible that if you use

vect.push_back(MyStruct(fieldValue1, fieldValue2))

the compiler will construct the new instance directly in the memory thatbelongs to the vector. It depends on how smart the optimizer is. You need to check the generated code to find out.

  • 2
    It turns out that the optimizer for gcc, at level O3, is not smart enough to avoid the copy. – Jim Hunziker Sep 19 '08 at 12:28

In C++11 (and boost) you can use the array version of unique_ptr to allocate an uninitialized array. This isn't quite an stl container, but is still memory managed and C++-ish which will be good enough for many applications.

auto my_uninit_array = std::unique_ptr<mystruct[]>(new mystruct[count]);

So here's the problem, resize is calling insert, which is doing a copy construction from a default constructed element for each of the newly added elements. To get this to 0 cost you need to write your own default constructor AND your own copy constructor as empty functions. Doing this to your copy constructor is a very bad idea because it will break std::vector's internal reallocation algorithms.

Summary: You're not going to be able to do this with std::vector.

  • This is the real issue. std::vector ought to realize it doesn't have to do any initialization if T has a trivial default constructor. Thanks for pointing out that the copy constructor is what's doing the unnecessary work here. – Eric Hein Feb 8 '17 at 0:40


try the method:


It will enable you to reserve enough memory for x items without initializing any (your vector is still empty). Thus, there won't be reallocation until to go over x.

The second point is that vector won't initialize the values to zero. Are you testing your code in debug ?

After verification on g++, the following code:

#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 ;

gives the following results:

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

The initialization you saw was probably an artifact.

[EDIT] After the comment on resize, I modified the code to add the resize line. The resize effectively calls the default constructor of the object inside the vector, but if the default constructor does nothing, then nothing is initialized... I still believe it was an artifact (I managed the first time to have the whole vector zerooed with the following code:

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

So... :-/

[EDIT 2] Like already offered by Arkadiy, the solution is to use an inline constructor taking the desired parameters. Something like

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

This will probably get inlined in your code.

But you should anyway study your code with a profiler to be sure this piece of code is the bottleneck of your application.

  • I wrote a note above. It's not the constructor of vector that initializes to 0. It's resize() that does. – Jim Hunziker Sep 18 '08 at 20:46
  • In this case MyStruct has a trivial constructor so nothing is initialized. This may be different than the OP's situation. – Greg Rogers Sep 18 '08 at 20:50
  • I think you're on the right track. I have no constructor defined in the struct, so its default constructor (I believe) zero-initializes. I'll check if adding a default constructor that does nothing solves the problem. – Jim Hunziker Sep 18 '08 at 21:00
  • If you have no constructor defined and all elements are POD types, then the constructor does nothing. If elements aren't POD's then it would simply call their default constructors. – Greg Rogers Sep 18 '08 at 21:08
  • Greg Rogers is right. My guess is that the memory was "zero" because of some process initialization independant of the code I did write. In C++, you do not pay for something that you don't use. So if you're writting C-like code, you should not have overhead. And vectors are quite good at that. – paercebal Sep 18 '08 at 21:20

Use the std::vector::reserve() method. It won't resize the vector, but it will allocate the space.


From your comments to other posters, it looks like you're left with malloc() and friends. Vector won't let you have unconstructed elements.


From your code, it looks like you have a vector of structs each of which comprises 2 ints. Could you instead use 2 vectors of ints? Then

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

Now you don't pay for copying a struct each time.

  • Interesting. This might just work -- it seems like it would avoid the construction of an intermediate object. – nobar Nov 11 '09 at 4:03

If you really insist on having the elements uninitialized and sacrifice some methods like front(), back(), push_back(), use boost vector from numeric . It allows you even not to preserve existing elements when calling resize()...


You can use a wrapper type around your element type, with a default constructor that does nothing. E.g.:

template <typename T>
struct no_init
    T value;

    no_init() { static_assert(std::is_standard_layout<no_init<T>>::value && sizeof(T) == sizeof(no_init<T>), "T does not have standard layout"); }

    no_init(T& v) { value = v; }
    T& operator=(T& v) { value = v; return value; }

    no_init(no_init<T>& n) { value = n.value; }
    no_init(no_init<T>&& n) { value = std::move(n.value); }
    T& operator=(no_init<T>& n) { value = n.value; return this; }
    T& operator=(no_init<T>&& n) { value = std::move(n.value); return this; }

    T* operator&() { return &value; } // So you can use &(vec[0]) etc.

To use:

std::vector<no_init<char>> vec;
vec.resize(2ul * 1024ul * 1024ul * 1024ul);

Do the structs themselves need to be in contiguous memory, or can you get away with having a vector of struct*?

Vectors make a copy of whatever you add to them, so using vectors of pointers rather than objects is one way to improve performance.

  • They have to be contiguous. They're in a buffer that's about to be sent over the network as one huge chunk. – Jim Hunziker Sep 18 '08 at 20:45

I don't think STL is your answer. You're going to need to roll your own sort of solution using realloc(). You'll have to store a pointer and either the size, or number of elements, and use that to find where to start adding elements after a realloc().

int *memberArray;
int arrayCount;
    memberArray = realloc(memberArray, sizeof(int) * (arrayCount + count);
        memberArray[arrayCount + i].d1 = data1[i];
        memberArray[arrayCount + i].d2 = data2[i];
    arrayCount += count;

I would do something like:

  const size_t mvSize = memberVector.size();
  memberVector.reserve(mvSize + count);

    memberVector.push_back(MyType(data1[i], data2[i]));

You need to define a ctor for the type that is stored in the memberVector, but that's a small cost as it will give you the best of both worlds; no unnecessary initialization is done and no reallocation will occur during the loop.

  • This doesn't seem to solve the problem since it uses a temporary MyType() and copies that into the vector. There is still a double initialization. – nobar Nov 11 '09 at 3:58

Your Answer

