default size of STL vector question

[zl2k]

hi, all
What is the default size of a stl vector? Suppose I have integers
needs to store in a vector and I know the max number of integer is,
say, 1000. Will it be more efficient that I first allocate size of
1000 and then use {vector[counter] = aNumber; counter++} to populate
the vector than by push_back(aNumber)? Of course I need to resize the
vector after it is populated. Thanks for help.
zl2k

[Ian Collins]

zl2k wrote:

hi, all
What is the default size of a stl vector?

There isn't one.

Suppose I have integers
needs to store in a vector and I know the max number of integer is,
say, 1000. Will it be more efficient that I first allocate size of
1000 and then use {vector[counter] = aNumber; counter++} to populate
the vector than by push_back(aNumber)?

Probably.

--
Ian Collins.

[Michael DOUBEZ]

Ian Collins a écrit :

zl2k wrote:

>hi, all
What is the default size of a stl vector?

There isn't one.

Create a vector an use vector<>::capacity() to know your STL
implementation's default size.

>

>Suppose I have integers
needs to store in a vector and I know the max number of integer is,
say, 1000. Will it be more efficient that I first allocate size of
1000 and then use {vector[counter] = aNumber; counter++} to populate
the vector than by push_back(aNumber)?

Probably.

You can use vector<>::reserve() instead. That way push_back() won't
cause reallocation and you can keep your vector size consistant with the
size of data held (and it doesn't initialize/destroy unnecessary data,
not that it matters with ints).

Michael

[zl2k]

On Oct 14, 12:19 am, Michael DOUBEZ <[e-mail]:

Ian Collins a écrit :

zl2k wrote:

hi, all
What is the default size of a stl vector?

There isn't one.

Create a vector an use vector<>::capacity() to know your STL
implementation's default size.

Suppose I have integers
needs to store in a vector and I know the max number of integer is,
say, 1000. Will it be more efficient that I first allocate size of
1000 and then use {vector[counter] = aNumber; counter++} to populate
the vector than by push_back(aNumber)?

Probably.

You can use vector<>::reserve() instead. That way push_back() won't
cause reallocation and you can keep your vector size consistant with the
size of data held (and it doesn't initialize/destroy unnecessary data,
not that it matters with ints).

Michael

But if I use reserve(maxAmount), then the maxAmount of memory is
acturally occupied by the vector, no matter how many elements are
actually there. Is that right?

[Michael DOUBEZ]

zl2k a écrit :

On Oct 14, 12:19 am, Michael DOUBEZ <[e-mail]:

>Ian Collins a écrit :

>>zl2k wrote:
Suppose I have integers
needs to store in a vector and I know the max number of integer is,
say, 1000. Will it be more efficient that I first allocate size of
1000 and then use {vector[counter] = aNumber; counter++} to populate
the vector than by push_back(aNumber)?
Probably.

You can use vector<>::reserve() instead. That way push_back() won't
cause reallocation and you can keep your vector size consistant with the
size of data held (and it doesn't initialize/destroy unnecessary data,
not that it matters with ints).

But if I use reserve(maxAmount), then the maxAmount of memory is
acturally occupied by the vector, no matter how many elements are
actually there. Is that right?

Yes but the result is the same with resize(). The standard does not
require that resize() give back memory and I assume that in most
implementation it doesn't.
It is one item of Herb Sutter's "Effective C++". There is a way that
potentialy allows you to get back the memory:
vector<intmyVector;//lot of memory reserved relatively to actual size

{vector<inttmp(myVector);
myVector.swap(tmp);
}

//here there is a chance to have myVector.capacity() reduced

Another possibility is that vector isn't really the container you need
or you can use another container to build the data and then copy them in
a vector.

Michael

[James Kanze]

On Oct 14, 5:25 am, zl2k <[e-mail]:

What is the default size of a stl vector?

0. Unless you specify a size, a vector is created empty,
without any elements.

Suppose I have integers needs to store in a vector and I know
the max number of integer is, say, 1000. Will it be more
efficient that I first allocate size of 1000 and then use
{vector[counter] = aNumber; counter++} to populate the vector
than by push_back(aNumber)?

It really depends on the implementation, but if you just do
push_back, without any reserve, then it's almost sure that using
push_back will be slower. On the other hand, the difference
between:

std::vector< int a( 1000 ) ;
for ( int i = 0 ; i < 1000 ; ++ i ) {
a[ i ] = ...
}

and

std::vector< int a ;
a.reserve( 1000 ) ;
for ( int i = 0 ; i < 1000 ; ++ i ) {
a.push_back( ... ) ;
}

will probably vary between implementations, and even between
processors, using the same implementation.

If instead of int, the vector is of a user defined type with an
expensive constructor and/or expensive assignment, the push_back
will be more favorable.

Of course I need to resize the
vector after it is populated.

Resizing a vector to make it smaller is very, very fast for the
built-in types. If a user defined type has a non-trivial
destructor, however, that destructor will be called for each
element removed by the resize.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Andrew Koenig]

"zl2k" <kd*******@gmail.comwrote in message
news:11*********************@z24g2000prh.googlegro ups.com...

What is the default size of a stl vector?

Zero.

Suppose I have integers
needs to store in a vector and I know the max number of integer is,
say, 1000. Will it be more efficient that I first allocate size of
1000 and then use {vector[counter] = aNumber; counter++} to populate
the vector than by push_back(aNumber)?

Your best bet is probably to reserve enough space (that is, call reserve
rather than resize) and then call push_back repeatedly.

Example:

vector<intv;
v.reserve(n);
for (int i = 0; i < n; ++i)
v.push_back(i);

That way, you avoid having to reallocate vector elements, and you also avoid
having to construct elements that you overwrite later.

[James Kanze]

On Oct 14, 6:00 pm, "Andrew Koenig" <[e-mail]:

"zl2k" <[e-mail] in message

news:11*********************@z24g2000prh.googlegro ups.com...

What is the default size of a stl vector?

Zero.

Suppose I have integers
needs to store in a vector and I know the max number of integer is,
say, 1000. Will it be more efficient that I first allocate size of
1000 and then use {vector[counter] = aNumber; counter++} to populate
the vector than by push_back(aNumber)?

Your best bet is probably to reserve enough space (that is, call reserve
rather than resize) and then call push_back repeatedly.

Example:

vector<intv;
v.reserve(n);
for (int i = 0; i < n; ++i)
v.push_back(i);

That way, you avoid having to reallocate vector elements, and
you also avoid having to construct elements that you overwrite
later.

That was more or less what I'd assumed until I actually measured
it. For an std::vector<int>, at least for the implementation I
measured (g++ on Sun Sparc, IIRC), doing the initializations was
slightly faster than the push_back's.

This obviously depends on the type--if default construction
followed by assignment is significantly slower than for int, for
example---and the implementation, and as a general rule, I'd
still go with reserve() plus the push_back(), since it will
always be almost as fast, and protects against the case where
construction plus assignment is expensive. But if performance
matters, you have to profile.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]