Variable-length std::array like

Question

As my usually used C++ compilers allow variable-length arrays (e.g. arrays depending on runtime size), I wonder if there is something like std::array with variable size? Of course std::vector is of variable size, but it allocates on heap, and reallocates on need.

I like to have a stack allocated array with size defined at runtime. Is there any std-template that may feature this? Maybe using std::vector with a fixed maximum size?

Answer 1

There are two proposals currently being worked on to bring run-time fixed size arrays to C++ which may be of interest to you:

• Runtime-sized arrays with automatic storage duration. This would make runtime sized arrays a language feature (like in C11). So you could do:

    void foo(std::size_t size) {
      int arr[size];
    }
  

• C++ Dynamic Arrays. This would bring a new container to the library, std::dynarray, which is given a fixed size at construction. It is intended to be optimized to be allocated on the stack when possible.

    void foo(std::size_t size) {
      std::dynarray<int> arr(size);
    }
  

These are both being worked on as part of an Array Extensions Technical Specification, which will be released alongside C++14.

UPDATE: std::dynarray is not implemented yet(25Aug2021).please refer to What is the status on dynarrays?

Answer 2

As Daniel stated in the comment, size of the std::array is specified as a template parameter, so it cannot be set during runtime.

You can though construct std::vector by passing the minimum capacity through the constructor parameter:

#include <vector>

int main(int argc, char * argv[])
{
    std::vector<int> a;
    a.reserve(5);
    std::cout << a.capacity() << "\n";
    std::cout << a.size();

    getchar();
}

But. Still vector's contents will be stored on the heap, not on the stack. The problem is, that compiler has to know, how much space should be allocated for the function prior to its execution, so it is simply not possible to store variable-length data on the stack.

Answer 3

Maybe using std::vector with a fixed maximal size?

If boost is allowed then boost::container::static_vector is the closest I can think of.

static_vector is a sequence container like boost::container::vector with contiguous storage that can change in size, along with the static allocation, low overhead, and fixed capacity of boost::array.

The size of each object is still fixed but it can be worth it if the number of allocations is significant and/or the item count is small

boost::container::small_vector is another solution if the vector can grow beyond the limit. The heap is only touched when the size is larger than the defined limit

small_vector is a vector-like container optimized for the case when it contains few elements. It contains some preallocated elements in-place, which can avoid the use of dynamic storage allocation when the actual number of elements is below that preallocated threshold.

boost::container::static_vector<int, 1024> my_array;
boost::container::small_vector<int, 1024> my_vector;

If you use Qt then QVarLengthArray is another way to go:

QVarLengthArray is an attempt to work around this gap in the C++ language. It allocates a certain number of elements on the stack, and if you resize the array to a larger size, it automatically uses the heap instead. Stack allocation has the advantage that it is much faster than heap allocation.

Example:

int myfunc(int n)
{
    QVarLengthArray<int, 1024> array(n + 1);
    ...
    return array[n];
}

Some other similar solutions:

• llvm::SmallVector
• Facebook's folly::small_vector
• Electronic Arts Standard Template Library's eastl::fixed_vector