What makes a vector so popular and useful in C plus plus?

Answer 1

A vector should always be considered the default container object unless you have good reason to use a more specialised container (such as a map, set or list).

A vector is essentially a variable-length array which automatically grows to accommodate new elements. If you require a fixed-length array, consider using std::array rather than std::vector or built-in array (C-style array).

As well as encapsulating the array and its current length, a vector also encapsulates a reserve to allow moderate expansion without reallocating the array upon every insertion. When the reserve is depleted, reallocation may occur however the optimum growth rate upon reallocation is around 160% which gives a reasonable balance between performance and memory consumption. You may set your own reserve if you can predict how many insertions you need to cater for, but in many cases there is very little to be gained by doing so.

Like all other standard-library containers, a vector is also a resource handle. That is, when a vector falls from scope, the elements within it are destroyed automatically. However, when the elements are pointers, the objects they refer to are not destroyed because pointers are not objects and therefore do not have destructors. The majority of vectors we use contain pointers, particularly when working with polymorphic objects (where we refer to a common base of the objects rather than the objects themselves). However, if a vector of pointers falls from scope before we destroy the objects it referred to, we create a resource leak.

To overcome this, we can easily populate vectors with smart pointers which are themselves resource handles with their own destructors. When the vector of smart pointers falls from scope, the smart pointers are destroyed automatically, which in turn automatically destroys the objects they referred to -- unless the smart pointer is a shared pointer in which case the object is only destroyed when the final reference falls from scope. Either way, we eliminate the risk of creating a resource leak at little to no cost (shared pointers incur some cost due to reference counting, but that cost is negligible compared to alternative solutions).

Being a resource handle, vectors implement the move semantic thus making it possible to pass and return vectors by value efficiently and at minimal cost. Built-in arrays, on the other hand, cannot be passed by value at all because arrays decay to pointers (hence we cannot implicitly copy a built-in array); we can only pass them by reference. However, because of the implicit decay to a pointer, passing a built-in array by reference is actually slightly less efficient than passing a vector by reference because the pointer alone does not tell us how many elements it refers to, so we also need to pass the array size. A vector carries all information with it, so passing the reference alone suffices.