收集对象比std :: vector更快

Question

I have a function that stores a lot of small objects (~16 bytes) in a vector, but it doesn't know in advance how many objects will be stored (imagine a recursive descent parser storing tokens for example).

std::vector<SmallObject> getObjects();

This is quite slow because of all the reallocation and copying (and apparently C++ even has to invoke the copy constructors if you don't use an optimised version (see "Object Relocation").

There must be a better way to do things like this where all I am doing to construct the vector is appending things. For example I could have a singly linked list of blocks that are filled, and convert everything to a single vector at the end, so everything only has to be copied once.

Is there anything in Boost or the standard C++ library that would help with this? Or any particularly clever algorithms?

Edit: To be more concrete:

struct SmallObject {
    unsigned id;
    boost::icl::discrete_interval<unsigned> ival;
};

Answer 1

The question which container is most efficient is always best answered by "it depends" and "measure it!".

Without any more information about your specific situation, there are two 'obvious' possibilities:

Use a linked list

The STL has two linked lists by default: a singly linked list std::forward_list and a doubly linked list std::deque . Moreover there is std::list which is usually the doubly-linked variant. Some quotes from the documentation:

std::forward [...] is implemented as a singly-linked list and essentially does not have any overhead compared to its implementation in C. Compared to std::list this container provides more space efficient storage when bidirectional iteration is not needed.

std::list [...] is usually implemented as a doubly-linked list. Compared to std::forward_list this container provides bidirectional iteration capability while being less space efficient.

std::deque (double-ended queue) [..] insertion and deletion at either end of a deque never invalidates pointers or references to the rest of the elements.

As opposed to std::vector, the elements of a deque are not stored contiguously: typical implementations use a sequence of individually allocated fixed-size arrays

Reserve space in a vector

If there is any way you can estimate an upper bound on the number of objects you will want to store, you can use that to reserve some space in advance.

For example, if you're reading these objects from a file, the number of objects may be at most the file size divided by 16, or the number of lines times two, or some other quick and easy calculation that you can do before constructing these objects.

In that case, if you reserve the capacity, you will allocate too much memory but prevent moves. Even if the upper bound is a bit too low, that's OK: you may still need to double the capacity once or twice but at least you prevent all the small increases (2 -> 4 -> 10 -> 16) at the start of the loop.