How do I best force-flatten a (one dimensional) vector for N values?

Question

I need something that behaves like an std::vector (interface/features/etc.) but I need it to be flat, ie it mustn't dynamically allocate a buffer. Clearly, this doesn't work in general, as the available size must be determined at compile time. But I want the type to be able to deal with N objects without additional allocations, and only if further items are pushed resort to dynamic allocation.

Some implementations of std::vector already do this, but only to the extent that it uses its existing members if the accumulated size of the content fits (I believe about three pointers-worth of payload). So, firstly , this is not a guarantee and secondly it is not configurable at compile time.

My thoughts are that I could either

• A) self-cook a type (probably bad because I'd loose the ridiculous performance optimisations from vector )
• B) use some sort of variant<vector<T>,array<T,N>> with an access wrapper (oh, the boilerplate)
• C) come up with a MyAllocator<T,N> that has an array<T,N> member which then may be used to hold the first N items and after this defer to allocator<T> but I'm not sure if this can work because I cannot find out whether vector must permanently hold an instance of its allocator type as a member (I believe it does not)

I figure I'm not the first person to want this, so perhaps there are already approaches to this? Some empirical values or perhaps even a free library?

Answer 1

You might find folly/small_vector of use.

folly::small_vector is a sequence container that implements small buffer optimization. It behaves similarly to std::vector, except until a certain number of elements are reserved it does not use the heap.

Like standard vector, it is guaranteed to use contiguous memory. (So, after it spills to the heap all the elements live in the heap buffer.)

Simple usage example:

small_vector<int,2> vec;
vec.push_back(0); // Stored in-place on stack
vec.push_back(1); // Still on the stack
vec.push_back(2); // Switches to heap buffer.

// With space for 32 in situ unique pointers, and only using a
// 4-byte size_type.
small_vector<std::unique_ptr<int>, 32, uint32_t> v;

// A inline vector of up to 256 ints which will not use the heap.
small_vector<int, 256, NoHeap> v;

// Same as the above, but making the size_type smaller too.
small_vector<int, 256, NoHeap, uint16_t> v;