Hey all, I've ran into a situation where I don't really know whether it would be better speed wise (not that it would make any real significance in my case) to use a set size array or a vector. I've been using lists and vectors so much, I'm starting to realize I might be improperly using them, by using them in situations where they are really unneeded. Basically I have some objects that are being constantly created and destroyed but at one time there will never ever be more than 20 of these objects all at once. Is it better to just declare an array Object objects[20] then to be constantly pushing and popping objects on and off of a vector? Also these objects will always be deleted and added in a sequential order, so I know using a list would be a bad choice. Also on a sort of related note, if the objects I'm storing are not polymorphic is there any point in dynamically allocating them? They also won't be passed around to other functions so there wouldn't be any overhead in that sense by coping. I think I've gotten in a habit of allocating almost all objects on the heap, which probably isn't so good. Thanks for any help, suggestions.

If you know that you'll only ever have 20 elements, then calling reserve(20) will allocate enough for 20 elements. After that, pushes are practically free because they'll never have to allocate additional memory.

CM

The set-size array will likely be slightly faster and should use 4 bytes less memory ( plus any extra heap storage the vector allocates ).

On the other hand, the reabability you gain from using push_back and pop_back and such is likely a much greater concern initally than the minute speed difference. Note that you can .reserve(20) the vector to avoid unnessesary reallocations.

The vector is also simpler to extend in the future should you need more than 20 at some point. It can also be easier to debug since you can use a debug version of vector that will always check array bounds and such, which isn't possible with a plain array.

Also, you're probably right that not putting them on the heap individually is a better choice. ( I say individually since vector uses heap memory [assuming you used the default allocator]. ) Especially since keeping vectors or arrays of pointers to heap objects is a nightmare to make properly exception-safe.

Quote:Original post by me22
Also, you're probably right that not putting them on the heap individually is a better choice. ( I say individually since vector uses heap memory [assuming you used the default allocator]. ) Especially since keeping vectors or arrays of pointers to heap objects is a nightmare to make properly exception-safe.

If that is meant to imply std::vector doesn't store elements in memory contiguously your completely mistaken, std::vector is guaranteed to store element in memory contiguously. std::vector seperates allocation/deallocation & construction/destruction for efficiency.

This is:

#include <vector>struct foo { int i; foo(int j): i(j) {} };int main() {   std::vector<foo> v;   v.reserve(10);   v.push_back(foo(30));};

is approximately equivalent to this:

#include <new>int main() {   foo* f = static_cast<foo*>(::operator new(sizeof(foo) * 10)); // allocates uninitialized memory only   ::new(&f[0]) foo(30); // in-place constructs only   //...   f[0].~foo(); // destroys only   ::operator delete(f); // deallocates only}

I tend to always use vectors where possible, it means I've got an easy way of avoiding fence-post errors as they're dynamically resizable.

Arrays have their uses, but I use vectors to store data. I use arrays for things like checking if a number has already been chosen (an array of booleans) and stuff like that.

My 2 cents.