M>void f( int n )
M>{
M>   int a[n];
M>}
M>

template <typename T, int SIZE>
class Array {
public:
    T& operator[](int i) {return data[i];}

private:
    T data[SIZE];
}

void f( int n )
{
   Array<int, n> a;
}

M>void f( int n )
M>{
M>   int a[n];
M>}
M>

begin
integer n;
input(n);
begin
integer array a[1:n];
...

M>void f( int n )
M>{
M>   int a[n];
M>}
M>

int *a = alloca( n * sizeof(int) );

void foo(size_t size) {
   int* a = new (alloca(size*sizeof(int))) int[size];
   for(size_t i = 0; i < size; i++)
       a[i] = 0;
}

M>void f( int n )
M>{
M>   int a[n];
M>}
M>

A stack overflow exception is generated if the space cannot be allocated. The stack overflow exception is not a C++ exception; it is a structured exception.

void f(int n)
{
   int* a;
   if ( n <= SMALL_MAGIC_NUMBER )
   {
       a = alloca(n * sizeof(int)); 
   }
   else
   {
       a = new int[n]; // или выход с ошибкой
   }

   // работаем с a, но помним, что можем быть должны освободить память, т.е. никаких return и throw, только goto cleanup
   // я люблю старый добрый C, ведь на нем пишет сам Торвальдс!

cleanup:
   // нужно хорошо постараться, чтобы в С++ всегда попасть сюда при выходе из функции
   // добро пожаловать в ручное управление памятью!
   if ( n > SMALL_MAGIC_NUMBER )
   {
      delete a;
   }
}

void f(int n)
{
   std::vector<int> a(n);

   // работаем с a, как обычным массивом, можно пользоваться throw и return, n может быть большим
}

1.9.1
The semantic descriptions in this International Standard define a parameterized nondeterministic abstract
machine. This International Standard places no requirement on the structure of conforming implementations.

1.9.7 An instance of each object with automatic storage duration (3.7.3) is associated with each entry into its
block. Such an object exists and retains its last-stored value during the execution of the block and while the
block is suspended (by a call of a function or receipt of a signal).

15.2.3
The process of calling destructors for automatic objects constructed on the path from a try block to a
throw-expression is called “stack unwinding.”

В то же время, потребности полностью удовлетворяются vector и scoped_array (возможно, с пользовательским аллокатором). Не менее (если не более) эффективно. Зачем вводить в язык синтаксическую конструкцию, если задачу можно решить существующими средствами?

void f( int n )
{
   int a[n];
}

{
  int x;
  int y[n];
  {
    int z;
    int t[m];

PD>{
PD>  int x;
PD>  int y[n];
PD>  {
PD>    int z;
PD>    int t[m];
PD>

push    ebp  
mov     ebp,esp
sub     esp,8
...
mov     [ebp-4],eax     ;   x
mov     [ebp-8],eax     ;   z
...
sub     esp,N           ;   N=4*n
...
sub     esp,M           ;   M=4*m
...
mov     [ebp-4],eax     ;   по прежнему x
mov     [ebp-8],eax     ;   по прежнему z
                        ;   т. о. имеем синтаксический оверхед только для самих динамических массивов
...