C ++中vlas的编译时与运行时const变量分配和分配

Question

I was working on a template function with non-type parameters (to avoid dynamic allocation of arrays) when a number of questions arose. My first question regards compile-time variable assignment. This arose from the following attempts at calls to the template function:

template<int n>
int *getDegrees(int A[][n]) {
  //return degrees
}

int main(int argc, char **argv) {
  int n = 10;
  int A[n][n];
  int *degs = getDegrees<n>(A);
}

Here, we have two errors: first, the compiler is unable to resolve the call to getDegrees(A) :

main.cc:27: error: no matching function for call to ‘getDegrees(int [(((long unsigned int)(((long int)n) + -0x00000000000000001)) + 1)][(((long unsigned int)(((long int)n) + -0x00000000000000001)) + 1)])’

Second, we're unable to use n in the template call as it isn't a constant expression. Simply making n constant does resolve the issues

const int n = 10;

however, if I were to do

int m = 10;
const int n = m; 

we get the same errors. While the second assignment may be allowed by the compiler, is it considered bad form to do so? Additionally, why would making n constant make a difference in resolving the function call?

My other question regards vlas: is memory allocated for them on the stack or the heap (and is this compiler-dependent)? There appears to have been some controversy in even allowing them in C++, should they be avoided in favor of vectors (or similar containers)?

Appreciate any insight!

Answer 1

I will try to answer whatever I could get from your question.
You can change the function prototype to receive the array by reference:

template<size_t n> // see the type
int *getDegrees(int (&A)[n][n]) {  // see the signature
  // ...
}

In above code, we are leveraging the fact that the array has same dimensions.
However, in general case it should be:

template<size_t n1, size_t n2> // see the type
int *getDegrees(int (&A)[n1][n2]) {  // see the signature
  // ...
}

If the size is too big then an error is issued by the compiler to inform you. eg (from g++):

error: size of array 'A' is too large

Now coming to the other question regarding the difference between assignment of the constant integer.
In C++, the array size has to be compile time constant and

const int n = 10;

fulfills that requirement. Because the compiler can make out that, 10 is a literal number being assigned to n .

In case of,

int m = 10;
const int n = m;

Compiler finds out that the source of n is not a compile time constant itself. And thus it makes the code ill formed.