size vs. capacity in a container, such as vector

[puzzlecracker]

Say I have a vector<int> intVec, and I reserve some sapce

intVec.reserve(100);

Is it fair to assume the vector contains enough space for 100
elements. In which case, the capacity -- ability to store 100 elements
without a relocation -- is 100.

Then what is the difference for intVec.resize(100)?

Just trying to understand the difference between these two beasts,
size and capacity.


Thank you.

 

[Ian Collins]

Say I have a vector<int> intVec, and I reserve some sapce

intVec.reserve(100);

Is it fair to assume the vector contains enough space for 100
elements. In which case, the capacity -- ability to store 100 elements
without a relocation -- is 100.

Then what is the difference for intVec.resize(100)?

Just trying to understand the difference between these two beasts,
size and capacity.

reserve() reserves space (capacity), but size() will not change.

try:

#include <vector>
#include <iostream>

int main()
{
std::vector<int> v1;
std::vector<int> v2;

v1.reserve(100);
v2.resize(100);

std::cout << "v1 " << v1.size() << ' ' << v1.capacity() << std::endl;
std::cout << "v2 " << v2.size() << ' ' << v2.capacity() << std::endl;
}

 

[Juha Nieminen]

Say I have a vector<int> intVec, and I reserve some sapce

intVec.reserve(100);

Is it fair to assume the vector contains enough space for 100
elements. In which case, the capacity -- ability to store 100 elements
without a relocation -- is 100.

Then what is the difference for intVec.resize(100)?

The difference is that, among other things, the new elements will
*not* be initialized with reserve(), and the push_back() and at()
functions will behave differently. Accessing elements beyond size() with
operator[] (even if space has been reserved for those elements) is
probably undefined behavior, especially if the element type is a class
which requires initialization.

 

[James Kanze]

The difference is that, among other things, the new elements
will *not* be initialized with reserve(), and the push_back()
and at() functions will behave differently. Accessing elements
beyond size() with operator[] (even if space has been reserved
for those elements) is probably undefined behavior, especially
if the element type is a class which requires initialization.

There's no probably...especially about it. It's undefined
behavior (except for at(), which is guaranteed to throw). In
any good implementation, something like

int
main()
{
std::vector< int > v ;
v.reserve( 100 ) ;
v[ 50 ] ;
return 0 ;
}

will result in a runtime error (core dump under Unix).

More generally, there are two main uses of reserve(): to ensure
the validity of iterators and pointers to elements, and as an
optimization measure. It doesn't affect the logical state of
the container.

 

[Hendrik Schober]

[...]
Just trying to understand the difference between these two beasts,
size and capacity.

One is the number of objects the vector actually has, the
other is the number of objects the vector could have without
needing to allocate more memory.

Thank you.

HTH,

Schobi