vector resizing

I thought vectors were supposed to resize themselves. But this crashes on my compiler:

Code:

---

#include <vector>

int main(void) {
    std::vector<int> v;

    for(int x = 0; x < 10; x ++) {
        v[x] = x;
    }

    return 0;
}

---

But this doesn't:

Code:

---

#include <vector>

int main(void) {
    std::vector<int> v(10);

    for(int x = 0; x < 10; x ++) {
        v[x] = x;
    }

    return 0;
}

---

What's happening here?

You're using random access to access an index that doesn't exist before you try to add an element to the vector.

you need to use the push_back( ) member function to put stuff into your vector.. then it will resize itself when necessary...

you can then use the [ ] subscript operator with your vector class object.. just like an array.. but only after the vector has been properly populated.

A vector has a given size at any time. Accessing an element outside this size will produce undefined behaviour.

A vector will not resize itself to fit your indices. It will automatically manage memory if you request it to resize itself. In other words, if you use insert() or push_back(), you can add elements as long as it can find a large enough block of memory, and you don't need to handle the memory management.

As far as I understand though, if you push an element onto a Vector so that is must resize itself, it expand to twice it's current size (double memory usage). For a small amount of items it's okay, but pushing that million and oneth element onto a Vector with one million spots will result in a Vector two million spots large.

I thought that the preferred way to do things was to start with an 'empty' vector and then resize as necessary, as vectors grow efficiently??

Quote:

---

Originally Posted by Epo

As far as I understand though, if you push an element onto a Vector so that is must resize itself, it expand to twice it's current size (double memory usage). For a small amount of items it's okay, but pushing that million and oneth element onto a Vector with one million spots will result in a Vector two million spots large.

---

If you already have a million items, chances are that you're going to push another 1000 instead of just one. And another 1000 soon after that.

Quote:

---

Originally Posted by kermit

I thought that the preferred way to do things was to start with an 'empty' vector and then resize as necessary, as vectors grow efficiently??

---

It's always more efficient to get the size right the first time. So if you know it beforehand, at least use reserve() to make the vector allocate enough space.

Quote:

---

Originally Posted by kermit

I thought that the preferred way to do things was to start with an 'empty' vector and then resize as necessary, as vectors grow efficiently??

---

I guess it depends on how you use them.. if you have a vector of ptrs or ints or simple objects its not bad..

if you have a vector of objects it could get a little messy

vector<foo> v;

because..
everytime it runs out of space it copies all objects into new space and destroys the old ones... so if the objects are large, it could get rather expensive even with a reasonable sized vector..

though i imagine common practice is to use vector to store ptrs.. atleast i try to always do that..

one other way to do it is to use vector::reserve(int) to reserve space.. this does not create x amounts of objects.. just gets enough contigious space for them..

thats my understanding of vectors anyhow...

<edit>oops didnt see your post CornedBee</edit>

Quote:

---

I thought that the preferred way to do things was to start with an 'empty' vector and then resize as necessary, as vectors grow efficiently??

---

If vectors resized every time you added an element, that would be inefficient. So, they double in size(or more depending on the implementation) when they are resized. If you need to add only one more element and the vector has to resize to allow you to do that, then the resizing is inefficient in that the vector allocates more memory than is required.

Yes, but my vector isn't resizing at all. I get a segmentation fault!

need code.

What do you mean? See the first post in this thread.

Quote:

---

You're using random access to access an index that doesn't exist before you try to add an element to the vector.

---

So you can't do this then? I thought you could.

No you can't.

edit::

No you shouldn't.. ;)

push_back(), insert() and the like will resize for you.. by index is just for accessing..

if you use a map, it will work like what you are doing though.. resizing by assigning to an index..

Code:

---

#include <map>
#include <string>

int main(void) {
    std::map<int, string> m;

    for(int x = 0; x < 10; x ++) {
        m[x] = someString;   
    }

    return 0;
}

---

hth

Okay, thanks.

Quote:

---

Originally Posted by dwks

Yes, but my vector isn't resizing at all. I get a segmentation fault!

---

This:

Code:

---

v[x]

---

calls the operator[]() function. Like an array, a vector indexes its elements, and if the index doesn't exist then the operator[]() function fails.

Vectors grow automatically in size when you add elements to the vector. There are several functions defined to allow you to add elements to a vector. However, operator[]() does not add elements to the vector--it tries to access elements that already exist. In a map<>, operator[]() does add elements to the map, but it doesn't work the same way with a vector.

If you want to add elements to a vector, then you have to use functions that do that.