Why can’t constant values be used to define an array’s initial size? in C programming

Why can’t constant values be used to define an array’s initial size?

There are times when constant values can be used and there are times when they can’t. A C program can use
what C considers to be constant expressions, but not everything C++ would accept.

When defining the size of an array, you need to use a constant expression. A constant expression will always
have the same value, no matter what happens at runtime, and it’s easy for the compiler to figure out what
that value is. It might be a simple numeric literal:

char a[ 512 ];
Or it might be a “manifest constant” defined by the preprocessor:
#define MAX 512
/* ... */
char a[ MAX ];
Or it might be a sizeof:
char a[ sizeof( struct cacheObject ) ];
Or it might be an expression built up of constant expressions:
char buf[ sizeof( struct cacheObject ) * MAX ];
Enumerations are allowed too.
An initialized const int variable is not a constant expression in C:
int max = 512; /* not a constant expression in C */
char buffer[ max ]; /* not valid C */
Using const ints as array sizes is perfectly legal in C++; it’s even recommended. That puts a burden on C++
compilers (to keep track of the values of const int variables) that C compilers don’t need to worry about.
On the other hand, it frees C++ programs from using the C preprocessor quite so much.

Cross Reference:

XV.1: Should C++ additions to a compiler be used in a C program?
XV.2: What is the difference between C++ and C?