C++ pointer of array: why cannot use an array defined by indirectly computed const var in function begin(array)?

Question

Error message in text:

I'm studying the book C++ Primer and encountering a problem listed below when coding an answer for one exercise:

#include<iostream>
#include<vector>

using namespace std;

int main() {
int i  = 3;
const int ci = 3;
size_t si = 3;
const size_t csi = 3;
int ia[i];
int cia[ci];
int sia[si];
int csia[csi];
int another_a[] = {1,2,3};

int *pi = begin(ia);       // error here
// no instance of overloaded function "begin" matches the argument list -- 
// argument types are: (int [i])
int *pci = begin(cia);
int *psi = begin(sia);     // error here
// no instance of overloaded function "begin" matches the argument list -- 
// argument types are: (int [si])
int *pcsi = begin(csia);
int *p_ano = begin(another_a);

vector<int> v = {1,3,4};
const int m = v.size();
const size_t n = v.size();
int ma[m];
int na[n];
int *pm = begin(ma);    // error here
// no instance of overloaded function "begin" matches the argument list -- 
// argument types are: (int [m])
int *pn = begin(na);    // error here
// no instance of overloaded function "begin" matches the argument list -- 
// argument types are: (int [n])

system("pause");
return 0;
}

I can understand that the first two errors are because that those two arrays are not defined using an constant variable. But why the last two, even if I have converted the size of the vector into a constant variable, the compiler still reports an error?

I'm quite confused about this, I would appreciate a lot for your kindly answer or discussion no matter it works or not.

Answer 1

First and foremost, you are using a compiler extension, but more on that later.

The standard begin overload which works for you is a template that accepts a reference to an array with a size that is a constant expression. In a nutshell, constant expressions are those expressions that a compiler can evaluate and know the value of during compilation.

A constant integer initialized with a constant expression like const int ci = 3;, can be used wherever a constant expression is required. So ci is, for all intents an purposes, a constant expression itself (equal to 3).

Modern C++ has a way to make such varaibles stand out as intended constant expressions, it's the constexpr specifier. So you could define ci like this:

constexpr int ci = 3;

It's exactly like your original code. But the same will not work for const int m = v.size();. Because constexpr requires a true constant expression as an initializer, unlike const. For a const variable is not necessarily a constant expression. It can just be a run-time variable that you cannot modify. And this is the case with m.

Because m is not a constant expression, what you defined is a variable length array. A C feature that is sometimes introduced as an extension by C++ compilers. And it doesn't gel with the std::begin template, which expects the array extent to be a constant expression.

Answer 2

Declaring arrays with non constant indexes isn't standard c++.

If you need dynamically sized arrays use std::vector.

Declaring a variable as const doesn't make it a compile time constant (required to declare a fixed sized array) it just means you can't modify it after it is declared.