Printable View
Say I want to implement a buffer that stores the last fifty lines of input should I use a list or a vector? The list seems as though it would have less overhead but I was wondering if there was some hidden caveat to using the list container.
Thanks,
PetrolMan
Besides storing the input, how will you access the input?
It seems like a queue, then, for which std::deque might be good?
Generally speaking you should use vector unless you have some reason to do otherwise. I don't see any reason to use list based on the information you've provided.
Since it is a buffer then a deque might be a good idea, as inserting or removing from the front would probably be necessary and vector doesn't do that so well compared to deque. The advantage of deque over list is that deque will have closer to constant time access if you need to look at one of the lines in the middle of the container.
I would think that between the three the list would have the most overhead in terms of size, but that shouldn't be noticeable.
I actually probably didn't give you all enough information. One thing I need to be able to do is to cycle through the data so in case someone wants to reuse the same input they can. This shouldn't really be a problem with any of the containers.
Say the container stores 50 lines of input, when the newest one is entered I want to just add it to the front of the container and then remove the oldest. There would never really be any need to do random insertions in the middle of the container or anything else.
Again, I figure any of these could do the job just fine but I was just kind of wondering about the overhead involved with each type of container.
Thanks,
PetrolMan
For 50 elements, I don't really see much reason to use anything other than vector - unless your text is REALLY long, in which case it may be better to store a (smart) pointer to your string, so that the vector itself is smaller and thus copies the elements faster when inserting in the middle.
--
Mats
Some people might object to this solution, but another option would be to implement a simple ring buffer instead of using an STL container directly (you could implement the ring buffer on top of a std::vector).
A std::deque provides the features you want, but there is the possibility that the deque slowly "walks around" in memory due to your specific access pattern (always pop-back then push-front).
I believe std::vector has the least overhead in size (0 bytes), whereas std::list has to have pointers to the head, and each node has a pointer to the next & previous node...
But for what you're describing, using an std::deque would be perfect because you'd only have to use the push_back() and pop_front() member functions to remove the oldest line and add a new one.
I was going to suggest a circular-buffer myself.Quote:
Originally Posted by brewbuck