vector template

quote:

---

Velochy

I was working opn a code and didnt understand what that vector meant(it was a 3d game code so i thought it really was a vector). However when i first understand what it does it instantly occured to me - is this gods gift to programmers? i mean we dont have to worry about memory allocation and in other aspects it works perfectly as an array.

---

quote:

---

Original post by Velochy

Now comes the question part - Are there any bad sides to it? Is it much more computationally expensive than normal pointers?

---

  
# include <vector>

using namespace std;

int main ()
{
  // Create a buffer of bytes, this is good so far.


  vector <char> buffer (1024 * 64);

  // Bad! This assumes that buffer''s elements are contiguous!


  some_C_function ((void*) &buffer [0]);
}
  

quote:

---

Original post by Crispy

Depending on your use of vector, it can be slow relative to other STL template classes, such as list, deque, etc. For example, vector performs appallingly comapred to list if you do a lot of deleteion, insertions, etc in the middle of it. For more specific info search the web or this forum - this topic has been discussed in several threads earlier.

---

quote:

---

Nevertheless, the C++ standard doesn''t guarantee the underlying implementation of the vector is an array, so you can''t use it like the following:

---

quote:

---

Original post by Crispy
For example, vector performs appallingly comapred to list if you do a lot of deleteion, insertions, etc in the middle of it.

---

quote:

---

Original post by cedricl

Uhh... Maybe doesn''t it guarantee that the implementation is an array, but I know it does guarantee that the elements are stored contiguously, so in effect, you can take the address of the first element and still be on the safe side.

---

quote:

---

Original post by cedricl

AFAIK, that''s why Herb Sutter (www.gotw.ca) recommends using deque instead of vector as the default container. It doesn''t have to store the elements contiguously, so it is generally more efficient.

---

quote:

---

Original post by cedricl
Uhh... Maybe doesn't it guarantee that the implementation is an array, but I know it does guarantee that the elements are stored contiguously, so in effect, you can take the address of the first element and still be on the safe side.

Original post by null_pointer
Nope.

http://www.gotw.ca/publications/mill10.htm
http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#69

---

quote:

---

You can of course make the assumption that vector will store its elements contiguously. Hopefully the defect report will be addressed in the next version of the C++ standard, but for now the fact is that the standard does not guarantee vector's elements are stored contiguously.

Herb Sutter says this himself:

The only (minor, and as you'll soon see, pretty much moot) fly in the ointment is that the C++ Standard as it's currently written doesn't guarantee that Example 1(c) will actually work portably on every C++ platform you might buy. The reason is pretty simple: Example 1(c) assumes that the internal contents of the vector are stored contiguously in the same format as is an array, but today's Standard doesn't require vendors to implement vector that way. If, for example, a vector implementation were to play games and store its contents in some other way (such as contiguously but in backwards order, or in sequential order but with an extra byte of housekeeping information between elements), then Example 1(c) would in fact fail miserably.

Original post by cedricl

AFAIK, that's why Herb Sutter (www.gotw.ca) recommends using deque instead of vector as the default container. It doesn't have to store the elements contiguously, so it is generally more efficient.

Original post by null_pointer
No, he's making an assumption about the implementation of std::vector. Please see the above links for clarification.

---

quote:

---

Also, I think his reason for using deque as the default container leans more towards ease of use than efficiency:

---

quote:

---

Original post by cedricl

Allow me to quote the very article you linked to. The Summary part:
It's safe to use vectors interchangeably with C-style arrays, and you should always prefer to use vectors or deques instead of arrays. Get in the habit of always using deque instead of vector whenever you don't need all of the contained elements to be contiguous in memory.

---

quote:

---

Original post by cedricl

Maybe so. See the benchmarks:
http://www.gotw.ca/gotw/054.htm

For some operations, deques are faster, and they are not that much slower for others.

---

quote:

---

Original post by null_pointer
What is your point?

I haven''t the faintest idea what you are arguing about. The fact that the standard does NOT GUARANTEE that vector''s elements are always contiguous demonstrates that Sutter is making an ASSUMPTION about the way vectors are implemented. That is simple logic.

---