当通过命令行 arguments 从配置文件中给出数组的大小时，我们如何使用 std::array？

Question

I am trying to use std::array whose size is given by a config file via command line argument in C++.

The config looks like this

100 // array size
... // other application parameters

Even in a more simpler setting where the array size is expected to be determined via command line argument, ie ./main 100 , this wouldn't work since the array size is not determined at compile time.

#include <array>                                                                                       

int main(int argc, char** argv) {

  if (argc != 2)
    return 1;

  int n = stoi(argv[1]);

  std::array<int, n> arr;
  ... // do my job

}

Are there any hacks to do the same thing using std::array , not dynamic STL containers?

Answer 1

You can't.

You need a dynamic container, if your dimensions are given at runtime. That's kind of the definition of dynamic!

If you are forbidden to use dynamic allocation, you will have to have a large std::array , with potentially many unused elements and a maximum supported upper bound for the figure in your config file.

Answer 2

If the set of permissible values for n is known at compile-time (say, 1 , 10 or 100 ), you can generate code for each of these values (this can lead to a code bloat, however) and then use if s to select the branch at run-time. With C++17 fold expressions this idea can be implemented in the following way:

template<std::size_t n>
void foo_impl(/* some parameters */) {
    std::array<int, n> arr;
    // ...
}

template<std::size_t... ns, typename... Args>
void foo(std::size_t n, Args&&... args) {
    assert(((n == ns) || ...));
    ((n == ns && (foo_impl<ns>(std::forward<Args>(args)...), true)), ...);
}

const std::size_t n = /* run-time value */;
foo<1, 10, 100>(n, /* some parameters */);

Here n == ns && expr is a well-known "hack" to evaluate expr only if the condition n == ns evaluates to true .

Answer 3

std::array requires you to know the size at compile time. The only way to do what you say would be to have your program compile another program with the right size value and execute it.

Best option here is probably to use a dynamic size container like std::vector .

Answer 4

Are there any hacks to do the same thing using std::array, not dynamic STL containers?

No, there are no such hacks. It is only possible to use std::array with a compile time constant size.

If you want dynamic size, then you need to use a dynamic array (or some other dynamic data structure).

Answer 5

It is not possible to define an std::array length on runtime.
You could used std::vector instead.

It behaves (kind of) like an array, just it allocated the block for the memory within the heap.
Your could could then be like this:

int n = stoi(argv[1]);
std::vector<int> my_data{};
my_data.resize(n); //Allocates n elements