std::array 的维度可以从命令行 arguments 读取吗？

Question

I have a C++ code where I decided to use std::array instead of std::vector and I want the size of the array to be read from command line.

In practice, this can be summarized with the following snippet

#include <iostream>
#include <array>
#include <sstream>

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

  std::size_t my_size;
  {
    std::istringstream is{argv[1]};
    is >> my_size;
  }
 
  std::cout << my_size<<std::endl;
  std::array<int,my_size> a;
  return 0;
}

The compiler gives the following error, which is due to the fact that my_size must be known at compile time.

error: the value of 'my_size' is not usable in a constant expression
14 | std::array<int,my_size> a;

Is there any way to let the size of an std::array to be given from command line? Or should I definitely use other containers? As dynamic arrays on the heap, or std::vector ?

Answer 1

Types and arrays sizes in particular must be known at compile time, hence the answer is: No.

You can implement some mapping from a runtime value to a compile-time constant. Something along the line of

size_t size;
std::cin >> size;
if (size == 10) {
     std::array<int,10> x;
     // use x
} else if (size == 20) [
     std::array<int,20> y;
     // use y
}

However, this is of very limited use, because x and y are of different type. When the size is only known at runtime it is easier to use a std::vector .

Answer 2

You can convert a relative small size to a constant. In C++17 it can be solved this way.

#include <iostream>
#include <array>
#include <sstream>
#include <utility>

constexpr std::size_t MAX_SIZE = 10;

template <class T, class F, T... I>
bool to_const(T value, F&& fn, std::integer_sequence<T, I...>) {
    return (
        (value == I && (fn(std::integral_constant<T, I>{}), true))
        || ... // or continue
    );
}

template <class T, class F>
bool to_const(T value, F&& fn) {
    return value <= MAX_SIZE &&
        to_const(value, fn, std::make_integer_sequence<T, MAX_SIZE + 1>{});
}

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

  std::size_t my_size;
  {
    std::istringstream is{argv[1]};
    is >> my_size;
  }
 
  std::cout << my_size<<std::endl;

  bool found = to_const(my_size, [](auto N)
  {
      std::array<int, N> a;
  });

  return 0;
}