Doing software 2d pixel buffers, blitting, etc. Someone was telling me there's absolutely no overhead involved in using an std::vector to represent objects, I was wondering if std::vector is indeed a good container for pixel buffers or if I should instead stick with a raw array like I've always used.
Thanks
When used properly, there shouldn't be any overhead in performance. But, they aren't exactly zero-overhead compared to raw arrays.
Size overhead
A typical std::vector container will use 3 pointers. Since you probably already track width and height yourself, your raw array could be done in one pointer since you already know the size.
Allocation overhead
You will incur some overhead when allocating the memory for the std::vector. However, this is the same overhead you incur if you allocate your own memory.
Zero-initialization overhead
std::vector will actually zero-init your memory when using resize(), which may or may not be significant to what you're doing.
But, from a performance standpoint, accessing a std::vector is the same as accessing an array.
When you use an std::vector, it is basically a thin wrapper around an array, which itself is basically just a block of values much like any other buffer. But the real question is why you want to do this? An std::vector is an improvement over a normal array mostly in that you can resize it by adding and removing values - but this is not an operation you would normally perform on a pixel buffer. So the vector seems to give you no benefit here.
These days you rarely use an array of pixels anyway, since most graphics are handled more efficiently using a library-specific type that is suited to the underlying hardware.
It's fine to use an std::vector for pixel data as long as you're careful not to allocate/deallocate/copy memory unnecessarily. For example, when you create a pixel buffer, use the vector's resize method to set it to the number of pixels required, then don't change its size afterward. When passing buffers around from one function to another, use a pointer or reference to the vector rather than passing by value. If you need to assign one vector to another, use the swap method where possible to avoid unnecessary copies.
In release builds there should be no overhead in accessing individual pixels using the vector's operator[]; as xcrypt mentioned in his comment, there could be some overhead in debug builds since the vector might insert range checks.
