Question

I’m currently in the process of changing the way I access my data structures, and I’m reviewing one of two solutions in the general case for vectors of vectors.

My incentive is simple; I want cache locality without giving up my interfaces.

I know the max-size of my vectors at compile time, but they won’t always be reaching the max. Common case is about 80%, and the total size of each vector is to be relatively small.
If I reach that max, I have made an error in logic somewhere, and want it to throw an error.

The first solution that came to mind, was to use a Pool allocator with std::vector, seemed like a good idea, but maybe a bit messy; having not used allocators properly before, I wasn’t too sure of the solution. I’m not much of a fan for storing the data separate to its owners, and I want the implementation to be as transparent as possible.

The second solution works great for me at the moment, but I want to make it a little bit less in line. At the moment, it is thus:

class Foo {
public:
        std::array<Bar, 10> bars;
        size_t used;

        // std::vector<Bar> bars; // reserved to 10... maybe

        void add(int var1, int var2) {
                if (used >= bars.size()) throw "Error";
                bars[used] = Bar(var1, var2);
                ++used;

                // std::vector alternative
                // bars.push_back(Bar(var1, var2));
        }
        void remove(size_t idx) {
                bars[idx] = bars.back();
                --used;

                // bars.back().~Bar(); // should happen, not sure if safe

                // std::vector alternative
                // bars[idx] = bars.back();
                // bars.pop_back();
        }
}

Which, as mentioned, works great. However, if I wanted to move this solution elsewhere, I’d rather not have to implement it again, and have proper semantics in terms of destruction (similar to that of an actual vector).

So, I was wondering what a good solution could be? Currently, I’ve started wrapping an std::array, but it is starting to get messy, and I’m sure this is solved problem.

Answer 1

See this link for several options for fixed-size data structures with a vector-like interface. In particular, boost::auto_buffer and eastl::fixed_vector seem viable options for your code.

Yet another alternative is to use Hinnant’s stack allocator with the regular std::vector, but MSVC++ has some trouble compiling it.