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?
Look up a C++ Reference and learn How To Ask Questions The Smart WayOriginally Posted by Bjarne Stroustrup (2000-10-14)
It seems like a queue, then, for which std::deque might be good?
I might be wrong.
Quoted more than 1000 times (I hope).Thank you, anon. You sure know how to recognize different types of trees from quite a long way away.
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
Compilers can produce warnings - make the compiler programmers happy: Use them!
Please don't PM me for help - and no, I don't do help over instant messengers.
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).
Code://try //{ if (a) do { f( b); } while(1); else do { f(!b); } while(1); //}
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 am probably the laziest programmer on the planet, a fact with which anyone who has ever seen my code will agree." - esbo, 11/15/2008
"the internet is a scary place to be thats why i dont use it much." - billet, 03/17/2010
I was going to suggest a circular-buffer myself.
My homepage
Advice: Take only as directed - If symptoms persist, please see your debugger
Linus Torvalds: "But it clearly is the only right way. The fact that everybody else does it some other way only means that they are wrong"
