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?
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?
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.
size<=capacity this works. To set the capacity use reserve. –
Moriah std::vector could be implemented to allocate it's inital capacity on stack, and switch to heap on the first reallocation. This will not work by reserve, as it has to be done on first allocation... but would be cool. However I doubt it works this way in the usual implementation. –
Poeticize Maybe using
std::vectorwith a fixed maximal size?
If boost is allowed then boost::container::static_vector and boost::container::small_vector are the closest I can think of
boost::container::static_vector<int, 1024> my_array;
boost::container::small_vector<int, 1024> my_vector;
static_vectoris a sequence container likeboost::container::vectorwith contiguous storage that can change in size, along with the static allocation, low overhead, and fixed capacity ofboost::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
If the vector can grow beyond the limit then just use boost::container::small_vector. The heap is only touched when the size is larger than the defined limit
small_vectoris 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.
If you use Qt then QVarLengthArray is another way to go:
QVarLengthArrayis 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::SmallVectorfolly::small_vectoreastl::fixed_vectorIf a 3rd party solution isn't allowed then you can roll your own solution by wrapping std::array in a struct to get a static vector
template<typename T, size_t N>
struct my_static_vector
{
explicit static_vector(size_t size) { } // ...
size_t size() const noexcept { return curr_size; }
static size_t capacity() const noexcept { return N; }
T& operator[](size_t pos) { return data[pos]; }
void push_back(const T& value) { data[curr_size++] = value; }
// ...
private:
std::array<typename T, N> data;
std::size_t curr_size;
}
And if small_vector is required then you can use std::variant to contain both the my_static_vector and the vector
template<typename T, size_t N>
struct my_small_vector
{
explicit small_vector(size_t size) { } // ...
size_t size() const noexcept {
if (data.index() == 0) {
return data.get<0>().size();
} else {
return data.get<1>().size();
}
}
static size_t capacity() const noexcept {
if (data.index() == 0) {
return data.get<0>().capacity();
} else {
return data.get<1>().capacity();
}
}
// ...
private:
std::variant<my_static_vector<T, N>, std::vector<T>> data;
}
© 2022 - 2024 — McMap. All rights reserved.
std::array, the size of the array is a template parameter, so it cannot be a runtime variable. I guessstd::vectoris your best bet. – Astartestd::vectorwith a custom allocator. Since you expect the data to be located "on the stack", presumably they will always be freed in reverse order they're allocated. It should be quite easy to write an extremely fast thread-local allocator given that restriction. The downside is that you will make a separate allocation up front to store the data, but this isn't all that different from what the OS does for your thread's stack - on a modern OS your block is virtual-only until used, just like the stack. But it won't benefit from the stack being hot in cache. – Lossaallocadoesn't work too nicely with stateful objects and this is tagged C++. – Moriah