FIFO std::queue<std::string> 过度复制大字符串？

Question

I'm implementing a simple producer thread and consumer thread that uses a shared std::queue<std::string> to pass very long strings from the producer to the consumer, locking a mutex while the queue is added to/removed from.

My main uncertainty is that I'm not sure how queue is managing the strings. Aside from when the initial insertion to the queue happens, are the entire strings being copied around during their lifetime in the queue?

Answer 1

The short answer is no. Unless you use quite an old compiler, they probably won't be copied at all while they're in the queue.

By default, std::queue uses an std::deque for its underlying storage. Unlike (for example) an std::vector , an std::deque doesn't usually use contiguous storage. Instead, its a vector of pointers, where each of those pointers refers to a fixed-size block of items being stored. When you add items to the deque, it doesn't copy those blocks containing the actual items at all. Instead, it just allocates another fixed-size block, and adds its address to the vector of pointers.

As a result, at least in the usual implementation of a deque (and therefore queue , at least by default) an item remains in exactly the same location in memory from the time it's pushed until the time it's popped.

But also note that even if you stored the items in something like a vector that can move items from one block of memory to another, it wouldn't normally cause a problem except (possibly) on quite an old compiler (pre C++-11). Starting with C++11, items can be moved rather than copied. When you move a long string, you'll copy copy a few bookkeeping items (pointer to the data, current size allocated, current size in use), but the actual data for the long string will not be copied.