std :: वेक्टर :: आकार () बनाम std: वेक्टर :: रिजर्व ()

Question 1

इस पोस्ट में std::vector::reserve()बनाम का उपयोग करने के बारे में टिप्पणी अनुभाग में एक धागा है std::vector::resize()।

यहाँ मूल कोड है:

void MyClass::my_method()
{
    my_member.reserve(n_dim);
    for(int k = 0 ; k < n_dim ; k++ )
         my_member[k] = k ;
}

मेरा मानना है कि तत्वों को लिखने के लिए vector, सही बात यह है कि कॉल करना है std::vector::resize(), नहीं std::vector::reserve()।

वास्तव में, निम्नलिखित परीक्षण कोड "क्रैश" में VS2010 SP1 में बनाता है:

#include <vector>

using namespace std;

int main()
{
    vector<int> v;
    v.reserve(10);
    v[5] = 2;

    return 0;
}

Am I right, or am I wrong? And is VS2010 SP1 right, or is it wrong?

Question 2

There are two different methods for a reason:

std::vector::reserve will allocate the memory but will not resize your vector, which will have a logical size the same as it was before.

std::vector::resize will actually modify the size of your vector and will fill any space with objects in their default state. If they are ints, they will all be zero.

After reserve, in your case, you will need a lot of push_backs to write to element 5. If you don't wish to do that then in your case you should use resize.

One thing about reserve: if you then add elements with push_back, until you reach the capacity you have reserved, any existing references, iterators or pointers to data in your vector will remain valid. So if I reserve 1000 and my size is 5, the &vec[4] will remain the same until the vector has 1000 elements. After that, I can call push_back() and it will work, but the stored pointer of &vec[4] earlier may no longer be valid.

Question 3

Answered here by Jan Hudec : Choice between vector::resize() and vector::reserve()

The two functions do vastly different things.

The resize() method (and passing argument to constructor is equivalent to that) will insert given number of elements to the vector (it has optional second argument to specify their value). It will affect the size(), iteration will go over all those elements, push_back will insert after them and you can directly access them using the operator[].

The reserve() method only allocates memory, but leaves it uninitialized. It only affects capacity(), but size() will be unchanged. There is no value for the objects, because nothing is added to the vector. If you then insert the elements, no reallocation will happen, because it was done in advance, but that's the only effect.

So it depends on what you want. If you want an array of 1000 default items, use resize(). If you want an array to which you expect to insert 1000 items and want to avoid a couple of allocations, use reserve().

EDIT: Blastfurnace's comment made me read the question again and realize, that in your case the correct answer is dont't preallocate manually. Just keep inserting the elements at the end as you need. The vector will automatically reallocate as needed and will do it more efficiently than the manual way mentioned. The only case where reserve() makes sense is when you have reasonably precise estimate of the total size you'll need easily available in advance.

EDIT2: Ad question edit: If you have initial estimate, than reserve() that estimate and if it turns out to be not enough, just let the vector do it's thing.

Question 4

It depends on what you want to do. reserve does not add any elements to the vector; it only changes the capacity(), which guarantees that adding elements will not reallocate (and e.g. invalidate iterators). resize adds elements immediately. If you want to add elements later (insert(), push_back()), use reserve. If you want to access elements later (using [] or at()), use resize. So youre MyClass::my_method can be either:

void MyClass::my_method()
{
    my_member.clear();
    my_member.reserve( n_dim );
    for ( int k = 0; k < n_dim; ++ k ) {
        my_member.push_back( k );
    }
}

or

void MyClass::my_method()
{
    my_member.resize( n_dim );
    for ( int k = 0; k < n_dim; ++ k ) {
        my_member[k] = k;
    }
}

Which one you chose is a question of taste, but the code you quote is clearly incorrect.

Question 5

There probably should be a discussion about when both methods are called with a number that's LESS than the current size of the vector.

Calling reserve() with a number smaller than the capacity will not affect the size or the capacity.

Calling resize() with a number smaller than current size the container will be reduced to that size effectively destroying the excess elements.

To sum up resize() will free up memory whereas reserve() will not.

Question 6

Yes you’re correct, Luchian just made a typo and is probably too coffee-deprived to realise his mistake.

Question 7

resize actually changes the amount of elements in the vector, new items are default constructed if the resize causes the vector to grow.

vector<int> v;
v.resize(10);
auto size = v.size();

in this case size is 10.

reserve on the other hand only requests that the internal buffer be grown to the specified size but does not change the "size" of the array, only its buffer size is changed.

vector<int> v;
v.reserve(10);
auto size = v.size();

in this case size is still 0.

So to answer your question, yes you are right, even if you reserve enough space you are still accessing uninitialized memory with the index operator. With an int thats not so bad but in the case of a vector of classes you would be accessing objects which have not been constructed.

Bounds checking of compilers set to debug mode can obviously be confused by this behavior which may be why you are experiencing the crash.