Re: std::vector: reserve required?
"Yannick Tremblay" <ytrembla@nyx.nyx.net> wrote in message
news:1215610529.288209@irys.nyx.net...
In article <2nQbk.13$wD.5@newsfe02.lga>,
Jim Langston <tazmaster@rocketmail.com> wrote:
No. It is unspecified behavior either way. reserve will allocate memory
to
extend the size of an array, but it does not actually grow the size.
resize() will both allocate the memory and extend the size also.
Note, that changing vec[jj] = jj;
to vec.push_back( jj );
would mean you don't need resize or reserve. However, if you know before
hand how much memory you are going to need, how many elements, you may
wish
to resize it to avoid needless calls to new.
Hmm, I would frown on the gratuitous use of resize()
Yes, resize should only be used (in this code) if the vec[jj] syntax or
using the buffer directly. Using push_back() .reserve() should suffice.
int en = 10;
vec<int> vec;
vec.reserve( en ); // Allocates memory, doesn't change size
for (int jj = 0; jj < en; ++jj)
vec.push_back( jj );
OK but more important if en is large.
Yes and no, since "large" is an abstract value. The simple addition of
..reserve() can save quite a number of new's and copies, enough that using it
if you know the size can make a big difference, and I don't know of any case
where it would actually hurt. Since en here is a non constant variable we
can figure that the programmer doesn't know what size it will actually be
here but will be set on some arbitary information. And since the program
knows at this point how big the vector will need to be, we might possibly
save a lot of needless news and copies by using reserve.
Usually, in my cases anyway, when using vectors I don't know before hand how
big the vector is going to be and just let it grow as needed.
Premature optimization? Hard to say. It depends on how often this code is
going to be called, etc.. but, really, if you know somehow how big the
vector is going to be, why not tell the vector?
alternately:
vec.resize( en ); // Allocates memory and changes size
// And initialise all elements !
for (int jj = 0; jj < en; ++jj)
vec[jj] = jj;
Yes, you do avoid reallocating of the vector buffer however,
vec.resize() will default initialize all elements in the vector. This
is likely to be much more expensive than using reserve() or even what
you would have to pay for using push_back() directly without
pre-reserving anything.
The typical use of resize would be more:
// some C API that returns data:
// void c_foo( int * buffer , size_t bufferSize )
//C++ code:
std::vector<int> v;
v.resize(200);
// get data using the C API:
c_foo( &v[0], v.size() );
// now you can use the data in the vector
Personally, I get uncomfortable using vec[jj] = ... syntax without knowing
that the elements were already in the vector. Which is where resize would
come in with using this syntax. In my own programs I would use the first
version, the .reserve() and push_back(), but it's a matter of choice I
think.
I pretty much agree with all your comments, other that I would use
..reserve() any time I knew before hand how big the vector was going to be.